feat: added a integration test for storage flows

Author: vr16x

src/core/batch/batch.ts

@@ -1,6 +1,7 @@
 import type { Address, Chain, PublicClient, Transport } from 'viem';
 import { contract } from '../contract';
 import { type ComposableCall, encodeExecuteComposable } from '../encoding';
+import { storage } from '../storage';
 import { ERC20Token, NativeToken } from '../token';
 import type { ComposableBatchInstance } from './types';
 
@@ -28,6 +29,9 @@ export function ComposableBatch<
     contract(address, abi) {
       return contract(publicClient, address, abi);
     },
+    storage() {
+      return storage(publicClient, accountAddress);
+    },
     get calls() {
       return [...calls];
     },

src/core/batch/types.ts

@@ -1,6 +1,7 @@
 import type { Address, Chain, Hex, PublicClient, Transport } from 'viem';
 import type { ContractInstance } from '../contract';
 import type { ComposableCall } from '../encoding';
+import type { StorageInstance } from '../storage';
 import type { ERC20TokenInstance, NativeTokenInstance } from '../token';
 
 export interface ComposableBatchInstance<
@@ -16,6 +17,7 @@ export interface ComposableBatchInstance<
     address: Address,
     abi: TAbi,
   ): ContractInstance<TAbi>;
+  storage(): StorageInstance;
   readonly calls: ComposableCall[];
   add(call: ComposableCall | ComposableCall[]): void;
   clear(): void;

src/core/storage/storage.ts

@@ -14,6 +14,7 @@ import { NAMESPACE_STORAGE_CONTRACT_ADDRESS } from './constants';
 import type {
   CheckStorageParams,
   GetStorageKeyParams,
+  ReadStorageParams,
   RuntimeValueStorageParams,
   StorageInstance,
   WriteStorageParams,
@@ -110,6 +111,23 @@ export function storage<
       return manager.getDefaultStorageSlotKey(resolvedAccountAddress, resolvedCallerAddress);
     },
 
+    async read({
+      storageKey,
+      accountAddress: accountAddressOverride,
+      callerAddress: callerAddressOverride,
+    }: ReadStorageParams = {}) {
+      const resolvedAccountAddress = accountAddressOverride ?? accountAddress;
+      const resolvedCallerAddress = callerAddressOverride ?? resolvedAccountAddress;
+
+      const slot = await getStorageSlot(resolvedAccountAddress, resolvedCallerAddress, storageKey);
+      const namespace = getStorageNamespace(resolvedAccountAddress, resolvedCallerAddress);
+
+      return contractInstance.read({
+        functionName: 'readStorage',
+        args: [namespace, slot],
+      }) as Promise<`0x${string}`>;
+    },
+
     async write({
       value,
       storageKey,

src/core/storage/types.ts

@@ -1,4 +1,4 @@
-import type { Address } from 'viem';
+import type { Address, Hex } from 'viem';
 import type { ComposableCall, RuntimeConstraint, RuntimeValue } from '../encoding';
 import type { Bytes32SupportedType } from '../encoding/utils';
 
@@ -23,6 +23,12 @@ export interface CheckStorageParams {
   callerAddress?: Address;
 }
 
+export interface ReadStorageParams {
+  storageKey?: bigint;
+  accountAddress?: Address;
+  callerAddress?: Address;
+}
+
 export interface GetStorageKeyParams {
   accountAddress?: Address;
   callerAddress?: Address;
@@ -31,6 +37,7 @@ export interface GetStorageKeyParams {
 export interface StorageInstance {
   readonly accountAddress: Address;
   getStorageKey(params?: GetStorageKeyParams): Promise<bigint>;
+  read(params?: ReadStorageParams): Promise<Hex>;
   write(params: WriteStorageParams): Promise<ComposableCall>;
   runtimeValue(params?: RuntimeValueStorageParams): Promise<RuntimeValue>;
   check(params: CheckStorageParams): Promise<ComposableCall>;

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

@@ -2,6 +2,7 @@ import {
   createMeeClient,
   getMEEVersion,
   MEEVersion,
+  toBytes32,
   toMultichainNexusAccount,
 } from '@biconomy/abstractjs';
 import { erc20Abi, getAddress, http } from 'viem';
@@ -167,4 +168,61 @@ describe('Integration — Biconomy abstractjs composable execution', () => {
       'UserOp [1] simulation failed. Revert reason: Execution reverted at contract 0x0000000020fe2f30453074ad916edeb653ec7e9d and reverted with error selector 0xa31844b0',
     );
   });
+
+  it('write value to namespace storage → use as runtime transfer amount → sweep remainder', async () => {
+    // 1. Init Nexus SCA on Base Sepolia and resolve its address + MEE client
+    const { scaAddress, meeClient } = await initNexus();
+
+    // 2. Fund SCA: EOA transfers mock USDC to the SCA and waits for 2 confirmations
+    const fundTxHash = await _walletClient.writeContract({
+      abi: erc20Abi,
+      address: USDC,
+      functionName: 'transfer',
+      args: [scaAddress, FUND_AMOUNT],
+    });
+
+    await publicClient.waitForTransactionReceipt({
+      hash: fundTxHash,
+      confirmations: 2,
+    });
+
+    // 3. Build composable batch: write storage → check storage → partial transfer → sweep remainder
+    const batch = ComposableBatch(publicClient, scaAddress);
+    const usdc = batch.erc20Token(USDC);
+    const storage = batch.storage();
+
+    // Pre-generate a storage key so all storage operations share the same slot
+    const storageValue = FUND_AMOUNT / 2n;
+    const storageKey = await storage.getStorageKey();
+
+    batch.add([
+      // Step A: write FUND_AMOUNT/2 into the shared namespace storage slot
+      await 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 }] }),
+      // Step C: transfer the runtime-resolved storage value (FUND_AMOUNT/2) from SCA to EOA
+      usdc.write({
+        functionName: 'transfer',
+        args: [_account.address, await storage.runtimeValue({ storageKey })],
+      }),
+      // Step D: sweep any remaining SCA balance (the other half) to the EOA
+      usdc.write({ functionName: 'transfer', args: [_account.address, usdc.runtimeBalance()] }),
+    ]);
+
+    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 }],
+      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 });
+
+    // 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));
+  });
 });