added a async handler for the batch module

Author: vr16x

src/core/batch/batch.test.ts

@@ -130,126 +130,111 @@ describe('ComposableBatch — add, length, clear, toCalldata', () => {
     expect(batch.length).toBe(0);
   });
 
-  it('add(single call) increments length by 1', async () => {
+  it('add(single call) increments length by 1', () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    const call = await batch
-      .contract(USDC, erc20Abi)
-      .write({ functionName: 'transfer', args: [WETH, 1n] });
-    batch.add(call);
+    batch.add(batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }));
     expect(batch.length).toBe(1);
   });
 
-  it('add(array of calls) increments length by the array size', async () => {
+  it('add(array of calls) increments length by the array size', () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
     const token = batch.contract(USDC, erc20Abi);
-    const calls = await Promise.all([
+    batch.add([
       token.write({ functionName: 'transfer', args: [WETH, 1n] }),
       token.write({ functionName: 'approve', args: [WETH, 1n] }),
     ]);
-    batch.add(calls);
     expect(batch.length).toBe(2);
   });
 
-  it('add() can be called multiple times and accumulates calls', async () => {
+  it('add() can be called multiple times and accumulates calls', () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
     const token = batch.contract(USDC, erc20Abi);
-    batch.add(await token.write({ functionName: 'transfer', args: [WETH, 1n] }));
-    batch.add(await token.write({ functionName: 'approve', args: [WETH, 1n] }));
+    batch.add(token.write({ functionName: 'transfer', args: [WETH, 1n] }));
+    batch.add(token.write({ functionName: 'approve', args: [WETH, 1n] }));
     expect(batch.length).toBe(2);
   });
 
-  it('clear() resets length to 0', async () => {
+  it('clear() resets length to 0', () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    const call = await batch
-      .contract(USDC, erc20Abi)
-      .write({ functionName: 'transfer', args: [WETH, 1n] });
-    batch.add(call);
+    batch.add(batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }));
     batch.clear();
     expect(batch.length).toBe(0);
   });
 
   it('toCalldata() returns a hex string', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    const call = await batch
-      .contract(USDC, erc20Abi)
-      .write({ functionName: 'transfer', args: [WETH, 1n] });
-    batch.add(call);
-    const calldata = await batch.toCalldata();
-    expect(calldata).toMatch(/^0x[0-9a-fA-F]+$/);
+    batch.add(batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }));
+
+    expect(await batch.toCalldata()).toMatch(/^0x[0-9a-fA-F]+$/);
   });
 
   it('toCalldata() with multiple calls returns a hex string', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
     const token = batch.contract(USDC, erc20Abi);
-    batch.add(await token.write({ functionName: 'transfer', args: [WETH, 1n] }));
-    batch.add(await token.write({ functionName: 'approve', args: [WETH, 1_000_000n] }));
-    const calldata = await batch.toCalldata();
-    expect(calldata).toMatch(/^0x[0-9a-fA-F]+$/);
+    batch.add(token.write({ functionName: 'transfer', args: [WETH, 1n] }));
+    batch.add(token.write({ functionName: 'approve', args: [WETH, 1_000_000n] }));
+
+    expect(await batch.toCalldata()).toMatch(/^0x[0-9a-fA-F]+$/);
   });
 
   it('toCalldata() produces different output for different calls', async () => {
     const batchA = createComposableBatch(publicClient, ACCOUNT);
     const batchB = createComposableBatch(publicClient, ACCOUNT);
-    const [transferCall, approveCall] = await Promise.all([
+    batchA.add(
       batchA.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }),
+    );
+    batchB.add(
       batchB.contract(USDC, erc20Abi).write({ functionName: 'approve', args: [WETH, 1n] }),
-    ]);
-    batchA.add(transferCall);
-    batchB.add(approveCall);
+    );
     const [a, b] = await Promise.all([batchA.toCalldata(), batchB.toCalldata()]);
     expect(a).not.toBe(b);
   });
 });
 
 // ---------------------------------------------------------------------------
-// ComposableBatch — calls getter
+// ComposableBatch — toCalls
 // ---------------------------------------------------------------------------
 
-describe('ComposableBatch — calls getter', () => {
-  it('calls is empty on a fresh batch', () => {
+describe('ComposableBatch — toCalls', () => {
+  it('toCalls() returns empty array on a fresh batch', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    expect(batch.calls).toHaveLength(0);
+    expect(await batch.toCalls()).toHaveLength(0);
   });
 
-  it('calls reflects added single call', async () => {
+  it('toCalls() reflects a single added call', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    const call = await batch
+    const writePromise = batch
       .contract(USDC, erc20Abi)
       .write({ functionName: 'transfer', args: [WETH, 1n] });
-    batch.add(call);
-    expect(batch.calls).toHaveLength(1);
-    expect(batch.calls[0].functionSig).toBe(call.functionSig);
+    batch.add(writePromise);
+    const calls = await batch.toCalls();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].functionSig).toBe((await writePromise).functionSig);
   });
 
-  it('calls reflects added array of calls', async () => {
+  it('toCalls() reflects an added array of calls', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
     const token = batch.contract(USDC, erc20Abi);
-    batch.add(
-      await Promise.all([
-        token.write({ functionName: 'transfer', args: [WETH, 1n] }),
-        token.write({ functionName: 'approve', args: [WETH, 1n] }),
-      ]),
-    );
-    expect(batch.calls).toHaveLength(2);
+    batch.add([
+      token.write({ functionName: 'transfer', args: [WETH, 1n] }),
+      token.write({ functionName: 'approve', args: [WETH, 1n] }),
+    ]);
+    expect(await batch.toCalls()).toHaveLength(2);
   });
 
-  it('calls is empty after clear()', async () => {
+  it('toCalls() returns empty array after clear()', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    batch.add(
-      await batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }),
-    );
+    batch.add(batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }));
     batch.clear();
-    expect(batch.calls).toHaveLength(0);
+    expect(await batch.toCalls()).toHaveLength(0);
   });
 
-  it('calls returns a copy — mutating it does not affect the batch', async () => {
+  it('toCalls() returns a copy — mutating it does not affect the batch', async () => {
     const batch = createComposableBatch(publicClient, ACCOUNT);
-    batch.add(
-      await batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }),
-    );
-    const snapshot = batch.calls;
+    batch.add(batch.contract(USDC, erc20Abi).write({ functionName: 'transfer', args: [WETH, 1n] }));
+    const snapshot = await batch.toCalls();
     snapshot.pop();
-    expect(batch.calls).toHaveLength(1);
+    expect(await batch.toCalls()).toHaveLength(1);
   });
 });
 

src/core/batch/batch.ts

@@ -12,13 +12,17 @@ export function createComposableBatch<
   publicClient: PublicClient<TTransport, TChain>,
   accountAddress: Address,
 ): ComposableBatchInstance<TTransport, TChain> {
-  const calls: ComposableCall[] = [];
+  const pendingCalls: (ComposableCall | Promise<ComposableCall>)[] = [];
+
+  async function build(): Promise<ComposableCall[]> {
+    return Promise.all(pendingCalls);
+  }
 
   return {
     publicClient,
     accountAddress,
     get length() {
-      return calls.length;
+      return pendingCalls.length;
     },
     erc20Token(tokenAddress) {
       return createERC20Token(publicClient, tokenAddress, accountAddress);
@@ -32,21 +36,21 @@ export function createComposableBatch<
     storage() {
       return createStorage(publicClient, accountAddress);
     },
-    get calls() {
-      return [...calls];
-    },
     add(call) {
       if (Array.isArray(call)) {
-        calls.push(...call);
+        pendingCalls.push(...call);
       } else {
-        calls.push(call);
+        pendingCalls.push(call);
       }
     },
     clear() {
-      calls.length = 0;
+      pendingCalls.length = 0;
+    },
+    async toCalls() {
+      return build();
     },
-    toCalldata() {
-      return encodeExecuteComposable(calls);
+    async toCalldata() {
+      return encodeExecuteComposable(await build());
     },
   };
 }

src/core/batch/types.ts

@@ -18,8 +18,10 @@ export interface ComposableBatchInstance<
     abi: TAbi,
   ): ContractInstance<TAbi>;
   storage(): StorageInstance;
-  readonly calls: ComposableCall[];
-  add(call: ComposableCall | ComposableCall[]): void;
+  add(
+    calls: ComposableCall | Promise<ComposableCall> | (ComposableCall | Promise<ComposableCall>)[],
+  ): void;
   clear(): void;
+  toCalls(): Promise<ComposableCall[]>;
   toCalldata(): Promise<Hex>;
 }

src/core/encoding/encoding.ts

@@ -559,7 +559,7 @@ export const prepareComposableOutputCalldataParams = async <
  * @param call - The calls to encode
  * @returns The encoded composable compatible call
  */
-export const encodeExecuteComposable = async (calls: ComposableCall[]): Promise<Hex> => {
+export const encodeExecuteComposable = (calls: ComposableCall[]): Hex => {
   const composableCalls = calls.map((call) => {
     return {
       functionSig: call.functionSig,

src/test/integration/batch-execution.test.ts

@@ -36,7 +36,7 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
         constraints: [{ gte: FUND_AMOUNT }],
       }),
       // Sweep: transfer the SCA's full runtime balance to the EOA
-      await usdc.write({
+      usdc.write({
         functionName: 'transfer',
         args: [_account.address, usdc.runtimeBalance()],
       }),
@@ -51,15 +51,16 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
     expect(Number(scaBalanceBefore)).to.greaterThanOrEqual(Number(FUND_AMOUNT));
 
     // 5. Get a quote for the composable instruction, then sign and submit it via MEE
+
     const quote = await meeClient.getQuote({
-      instructions: [{ calls: batch.calls, chainId: baseSepolia.id, isComposable: true }],
+      instructions: [{ calls: await batch.toCalls(), chainId: baseSepolia.id, isComposable: true }],
       simulation: { simulate: true },
       feeToken: { address: USDC, chainId: baseSepolia.id },
     });
 
     // 6. Execute the signed quote and wait for the supertransaction to settle
     const { hash } = await meeClient.executeQuote({ quote });
-    await meeClient.waitForSupertransactionReceipt({ hash });
+    await meeClient.waitForSupertransactionReceipt({ hash, mode: 'fast-block' });
 
     // 7. Assert SCA balance has been swept to zero (minus fees)
     const scaBalanceAfter = await usdc.read({ functionName: 'balanceOf', args: [scaAddress] });
@@ -82,7 +83,7 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
         constraints: [{ gte: 2n * FUND_AMOUNT }],
       }),
       // Sweep: would transfer runtime balance to EOA (never reached due to revert)
-      await usdc.write({
+      usdc.write({
         functionName: 'transfer',
         args: [_account.address, usdc.runtimeBalance()],
       }),
@@ -91,9 +92,12 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
     expect(batch.length).toBe(2);
 
     // 3. Submit quote — expect simulation to revert because pre-check constraint is not satisfied
+
     await expect(
       meeClient.getQuote({
-        instructions: [{ calls: batch.calls, chainId: baseSepolia.id, isComposable: true }],
+        instructions: [
+          { calls: await batch.toCalls(), chainId: baseSepolia.id, isComposable: true },
+        ],
         simulation: { simulate: true },
         feeToken: { address: USDC, chainId: baseSepolia.id },
       }),
@@ -112,7 +116,7 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
 
     batch.add([
       // Sweep: transfer runtime balance from SCA to EOA
-      await usdc.write({
+      usdc.write({
         functionName: 'transfer',
         args: [_account.address, usdc.runtimeBalance()],
       }),
@@ -127,9 +131,12 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
     expect(batch.length).toBe(2);
 
     // 3. Submit quote — expect simulation to revert because post-check constraint is not satisfied
+
     await expect(
       meeClient.getQuote({
-        instructions: [{ calls: batch.calls, chainId: baseSepolia.id, isComposable: true }],
+        instructions: [
+          { calls: await batch.toCalls(), chainId: baseSepolia.id, isComposable: true },
+        ],
         simulation: { simulate: true },
         feeToken: { address: USDC, chainId: baseSepolia.id },
       }),
@@ -156,16 +163,16 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
 
     batch.add([
       // Step A: write FUND_AMOUNT/2 into the shared namespace storage slot
-      await storage.write({ value: storageValue, storageKey }),
+      storage.write({ value: storageValue, storageKey }),
       // Step B: assert the stored value equals what was just written before proceeding
-      await storage.check({ storageKey, constraints: [{ eq: storageValue }] }),
+      storage.check({ storageKey, constraints: [{ eq: storageValue }] }),
       // Step C: transfer the runtime-resolved storage value (FUND_AMOUNT/2) from SCA to EOA
-      await usdc.write({
+      usdc.write({
         functionName: 'transfer',
         args: [_account.address, await storage.runtimeValue({ storageKey })],
       }),
       // Step D: sweep any remaining SCA balance (the other half) to the EOA
-      await usdc.write({
+      usdc.write({
         functionName: 'transfer',
         args: [_account.address, usdc.runtimeBalance()],
       }),
@@ -174,15 +181,16 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
     expect(batch.length).toBe(4);
 
     // 4. Get a quote for the composable instruction, then sign and submit it via MEE
+
     const quote = await meeClient.getQuote({
-      instructions: [{ calls: batch.calls, chainId: baseSepolia.id, isComposable: true }],
+      instructions: [{ calls: await batch.toCalls(), chainId: baseSepolia.id, isComposable: true }],
       simulation: { simulate: true },
       feeToken: { address: USDC, chainId: baseSepolia.id },
     });
 
     // 5. Execute the signed quote and wait for the supertransaction to settle
     const { hash } = await meeClient.executeQuote({ quote });
-    await meeClient.waitForSupertransactionReceipt({ hash });
+    await meeClient.waitForSupertransactionReceipt({ hash, mode: 'fast-block' });
 
     // 6. Assert the on-chain storage slot holds the value that was written in step A
     expect(await storage.read({ storageKey })).to.eq(toBytes32(storageValue));