transactions.paginate()

transactions.paginate(
  query?: ListTransactionsQuery, 
  pageSize?: number
): AsyncGenerator<Transaction[]>

interface ListTransactionsQuery {
  payer?: string;      // Filter by payer address
  pay_to?: string;     // Filter by recipient address
  entry_id?: string;   // Filter by entry ID
}

for await (const batch of grapevine.transactions.paginate()) {
  console.log(`Processing ${batch.length} transactions`);
  
  for (const tx of batch) {
    console.log(`${tx.payer} → ${tx.pay_to}: ${tx.amount}`);
  }
}

// Get all payments from a specific wallet
for await (const batch of grapevine.transactions.paginate({ 
  payer: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb' 
})) {
  console.log(`Processing ${batch.length} payments`);
}

// Use larger batches for efficiency
for await (const batch of grapevine.transactions.paginate({}, 100)) {
  console.log(`Processing batch of ${batch.length}`);
}

async function getAllTransactions(query?: ListTransactionsQuery) {
  const allTransactions: Transaction[] = [];
  
  for await (const batch of grapevine.transactions.paginate(query, 100)) {
    allTransactions.push(...batch);
    console.log(`Loaded ${allTransactions.length} transactions...`);
  }
  
  return allTransactions;
}
 
// Usage
const myPayments = await getAllTransactions({ payer: myAddress });
console.log(`Total payments: ${myPayments.length}`);

async function calculateTotalRevenue(walletAddress: string) {
  let totalRevenue = BigInt(0);
  let transactionCount = 0;
  
  for await (const batch of grapevine.transactions.paginate({ 
    pay_to: walletAddress 
  })) {
    for (const tx of batch) {
      totalRevenue += BigInt(tx.amount);
      transactionCount++;
    }
  }
  
  return {
    totalRevenue: formatUSDC(totalRevenue.toString()),
    transactionCount
  };
}
 
function formatUSDC(weiAmount: string): string {
  const usdc = Number(BigInt(weiAmount)) / 1e6;
  return `${usdc.toFixed(2)}`;
}

async function getUniqueBuyers(sellerAddress: string) {
  const buyers = new Set<string>();
  
  for await (const batch of grapevine.transactions.paginate({ 
    pay_to: sellerAddress 
  })) {
    for (const tx of batch) {
      buyers.add(tx.payer);
    }
  }
  
  return Array.from(buyers);
}
 
// Usage
const buyers = await getUniqueBuyers(myAddress);
console.log(`You have ${buyers.length} unique buyers`);

async function exportTransactions(query: ListTransactionsQuery) {
  const rows: string[] = ['ID,Date,Payer,Recipient,Amount,Asset,Entry ID,Hash'];
  
  for await (const batch of grapevine.transactions.paginate(query, 100)) {
    for (const tx of batch) {
      rows.push([
        tx.id,
        new Date(tx.created_at * 1000).toISOString(),
        tx.payer,
        tx.pay_to,
        formatUSDC(tx.amount),
        tx.asset,
        tx.entry_id || '',
        tx.transaction_hash
      ].join(','));
    }
  }
  
  return rows.join('\n');
}
 
// Usage
const csv = await exportTransactions({ pay_to: myAddress });
console.log(csv);

async function downloadAllTransactions(
  query: ListTransactionsQuery,
  onProgress?: (count: number) => void
) {
  const transactions: Transaction[] = [];
  
  for await (const batch of grapevine.transactions.paginate(query, 100)) {
    transactions.push(...batch);
    onProgress?.(transactions.length);
  }
  
  return transactions;
}
 
// Usage with React state
const [progress, setProgress] = useState(0);
 
const transactions = await downloadAllTransactions(
  { payer: address },
  setProgress
);

async function findFirstLargeTransaction(minAmount: bigint) {
  for await (const batch of grapevine.transactions.paginate({}, 50)) {
    for (const tx of batch) {
      if (BigInt(tx.amount) >= minAmount) {
        return tx; // Exit early when found
      }
    }
  }
  return null;
}
 
// Find first transaction over $100
const largeTx = await findFirstLargeTransaction(BigInt(100_000_000)); // 100 USDC