getOperations: ActorMethod<[bigint, bigint], Array<OperationAndId>>

interface OperationAndId {
  id: bigint;
  operation: Operation;
}

interface Operation {
  time: Time; // bigint timestamp
  typeof: OperationType;
}

type OperationType = 
  | { access: { user: string } }
  | { token: { tokenid: TokenID, deltas: Array<Delta> } }
  | { trade: TradeOperation }
  | { other: { data: Metadata, name: string } }
  | { mint: { tokenid: TokenID, data: Metadata } }
  | { transaction: TransactionOperation }

interface TradeOperation {
  amount_token: TokenAmount;
  tokenid: TokenID;
  user: string;
  typeof: TradeType; // { buy: null } | { sell: null }
  bonded: boolean;
  amount_btc: TokenAmount;
  price: TokenAmount;
}

interface TransactionOperation {
  tokenid: TokenID;
  balance: TokenAmount;
  metadata: Metadata;
  user: string;
  typeof: { add: null } | { sub: null };
  description: string;
  amount: TokenAmount;
}

// Get first 10 operations
const operations = await actor.getOperations(0n, 10n);

console.log(`Retrieved ${operations.length} operations`);
operations.forEach(op => {
  console.log(`Operation ${op.id}:`, op.operation);
});

async function getAllOperations() {
  const limit = 100n;
  let offset = 0n;
  let allOperations = [];
  
  while (true) {
    const batch = await actor.getOperations(offset, limit);
    
    if (batch.length === 0) break; // No more operations
    
    allOperations.push(...batch);
    offset += BigInt(batch.length);
    
    if (batch.length < limit) break; // Last batch
  }
  
  return allOperations;
}

const operations = await actor.getOperations(0n, 100n);

// Filter trade operations
const tradeOps = operations.filter(op => 'trade' in op.operation.typeof);

// Filter token operations  
const tokenOps = operations.filter(op => 'token' in op.operation.typeof);

// Filter by specific user
const userOps = operations.filter(op => {
  const opType = op.operation.typeof;
  if ('trade' in opType) {
    return opType.trade.user === "specific-user-id";
  }
  return false;
});