@tapforce/pod-bridge-sdk 1.2.5 → 2.1.1

package/README.md

@@ -1,26 +1,27 @@
 # Pod Bridge SDK
 
-TypeScript SDK for bridging ERC20 tokens between POD and EVM chains (e.g., Sepolia/ETH).
+TypeScript SDK for bridging tokens between POD and EVM chains (e.g., ETH Mainnet).
 
 ## Architecture
 
 ```
-ETH → Pod: Deposit on ETH, AUTO-CLAIM on Pod (no claim TX needed)
-Pod → ETH: Deposit on Pod, claim on ETH with aggregated validator signatures
+ETH -> Pod: Deposit on ETH, AUTO-CLAIM on Pod (no claim TX needed)
+Pod -> ETH: Deposit on Pod, claim on ETH with proof from pod_getBridgeClaimProof RPC
 ```
 
 **Key points:**
-- Only ERC20 tokens supported (wrap ETH to WETH first)
-- `Deposit.id` on source chain = `Claim.id` on destination chain (for tracking)
-- Token addresses differ between chains
+- ERC20 and native token bridging supported
+- Token addresses differ between chains (e.g., USDC on ETH maps to native `0xEeee...EEeE` on Pod)
+- Use ETH-side decimals for amounts (e.g., `1e6` for 1 USDC, not `1e18`)
+- Pod transactions require EIP-1559 (type 2) gas params, not legacy `gasPrice`
 
 ## Features
 
-- **Bridge ERC20 Deposits**: Deposit tokens to the bridge
-- **Track Bridge Requests**: Query deposits sent/received by any address  
+- **Bridge Deposits**: Deposit ERC20 or native tokens to the bridge (with optional CLOB integration)
+- **Claim with Proof**: Claim on ETH using `pod_getBridgeClaimProof` RPC
+- **Track Bridge Requests**: Query deposits sent/received by any address
 - **Claim Status Tracking**: Monitor claim status and finality
 - **Transaction Building**: Generate unsigned transactions ready for signing
-- **Type-Safe**: Full TypeScript support
 
 ## Installation
 
@@ -35,12 +36,13 @@ pnpm add @tapforce/pod-bridge-sdk
 ## Quick Start
 
 ```typescript
-import { 
+import {
   SourceChainToPodActionClient,
   PodToSourceChainActionClient,
   PodBridgeTrackerClient,
-  PodBridgeConfig,
-  BRIDGE_ABI
+  getBridgeClaimProof,
+  SOURCE_CHAIN_BRIDGE_ABI,
+  POD_BRIDGE_ABI,
 } from '@tapforce/pod-bridge-sdk';
 ```
 
@@ -53,10 +55,10 @@ import { PodBridgeActionsClientConfig } from '@tapforce/pod-bridge-sdk';
 
 const actionConfig: PodBridgeActionsClientConfig = {
   sourceChain: {
-    contractAddress: '0x...' // Bridge contract on ETH/Sepolia
+    contractAddress: '0x...' // BridgeDepositWithdraw on ETH
   },
   pod: {
-    contractAddress: '0x...' // Bridge contract on Pod
+    contractAddress: '0x0000000000000000000000000000000000B41D9E' // BridgeMintBurn on Pod
   }
 };
 ```
@@ -69,13 +71,13 @@ import { ethers } from 'ethers';
 
 const trackerConfig: PodBridgeConfig = {
   sourceChain: {
-    provider: new ethers.JsonRpcProvider('https://sepolia.infura.io/v3/YOUR_KEY'),
+    provider: new ethers.JsonRpcProvider('https://eth-mainnet.rpc.example'),
     contractAddress: '0x...',
-    deploymentBlock: 9502541 // Optional: avoids indexing empty blocks
+    deploymentBlock: 12345678 // Optional: avoids indexing empty blocks
   },
   pod: {
     provider: new ethers.JsonRpcProvider('https://rpc.pod.network'),
-    contractAddress: '0x...',
+    contractAddress: '0x0000000000000000000000000000000000B41D9E',
     deploymentBlock: 0
   }
 };
@@ -83,76 +85,81 @@ const trackerConfig: PodBridgeConfig = {
 
 ## Usage
 
-### ETH → Pod (Auto-claim)
+### ETH -> Pod (Auto-claim)
 
-Deposits on ETH are automatically claimed on Pod after block finalization (~15 min on Sepolia).
+Deposits on ETH are automatically claimed on Pod after block finalization.
 
 ```typescript
 const client = new SourceChainToPodActionClient(actionConfig);
 
-// Create deposit transaction
+// Simple deposit (bridge only)
 const depositTx = client.deposit({
-  token: '0xWETH_ADDRESS',        // ERC20 token on ETH
-  amount: ethers.parseEther('1'),
-  destinationWalletAddress: '0x...', // Recipient on Pod
-  from: '0x...'                      // Optional
+  token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC on ETH
+  amount: ethers.parseUnits('1', 6),  // 1 USDC (use ETH-side decimals)
+  destinationWalletAddress: '0x...',
+  from: '0x...',
+  // permit: '0x...' // Optional: ERC20 permit bytes
 });
 
-// Send transaction
+// CLOB deposit — bridge and deposit to orderbook in one TX:
+// const clobTx = client.deposit({
+//   token: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT on ETH
+//   amount: ethers.parseUnits('1', 6),
+//   destinationWalletAddress: '0x...',
+//   callContract: '0x000000000000000000000000000000000000C10B', // CLOB orderbook
+//   reserveBalance: ethers.parseUnits('0.5', 6), // Keep 0.5, forward 0.5 to CLOB
+//   from: '0x...',
+// });
+
+// Don't forget to approve the bridge contract first for ERC20 tokens
 const tx = await signer.sendTransaction(depositTx);
 const receipt = await tx.wait();
 
 // No claim needed - balance auto-credited on Pod after finalization
 ```
 
-### Pod → ETH (Manual claim with signatures)
+### Pod -> ETH (Claim with proof)
 
-Deposits on Pod require manual claim on ETH with aggregated validator signatures.
+Deposits on Pod require claiming on ETH with a proof from `pod_getBridgeClaimProof`.
 
 ```typescript
-import { 
+import {
   PodToSourceChainActionClient,
-  extractAggregatedSignaturesWithValidators 
+  getBridgeClaimProof,
+  ClaimProofData,
 } from '@tapforce/pod-bridge-sdk';
 
 const client = new PodToSourceChainActionClient(actionConfig);
 
 // Step 1: Deposit on Pod
 const depositTx = client.deposit({
-  token: '0xPOD_TOKEN_ADDRESS',   // ERC20 token on Pod
-  amount: ethers.parseEther('1'),
-  destinationWalletAddress: '0x...', // Recipient on ETH
-  from: '0x...'
+  token: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', // Native token on Pod
+  amount: ethers.parseUnits('1', 6),  // Use ETH-side decimals (1 USDC = 1e6)
+  destinationWalletAddress: '0x...',
+  from: '0x...',
 });
 
-const tx = await podSigner.sendTransaction(depositTx);
-const receipt = await tx.wait();
-
-// Step 2: Get the receipt with validator signatures
-const podReceipt = await podProvider.send('eth_getTransactionReceipt', [tx.hash]);
-
-// Step 3: Get committee for v-value recovery
-const committee = await podProvider.send('pod_getCommittee', {});
+// Pod requires EIP-1559 gas params (all zeros for free transactions)
+const tx = await podSigner.sendTransaction({
+  ...depositTx,
+  maxFeePerGas: 0n,
+  maxPriorityFeePerGas: 0n,
+  gasLimit: 0n,
+});
 
-// Step 4: Extract aggregated signatures (65-byte format with correct v-values)
-const aggregatedSignatures = extractAggregatedSignaturesWithValidators(
-  podReceipt,
-  committee.validators  // [[0, "02..."], [1, "03..."], ...] compressed pubkeys
-);
+// Step 2: Get claim proof from Pod RPC
+const { proof, auxTxSuffix } = await getBridgeClaimProof(podProvider, tx.hash);
 
-// Step 5: Claim on ETH
-const claimTx = client.claim({
-  claimData: {
-    ethTokenAddress: '0xETH_TOKEN_ADDRESS', // Token on ETH (different from Pod)
-    amount: ethers.parseEther('1'),
-    to: '0x...',                            // Recipient
-    committeeEpoch: 0,                      // Hardcoded for now
-    aggregatedSignatures,                   // 65-byte signatures (r,s,v) concatenated
-    depositTxHash: tx.hash                  // Deposit TX hash from Pod
-  },
-  from: '0x...'
-});
+// Step 3: Claim on ETH
+const claimData: ClaimProofData = {
+  ethTokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC on ETH
+  amount: ethers.parseUnits('1', 6),  // Must match deposited amount
+  to: '0x...',
+  proof,
+  auxTxSuffix,
+};
 
+const claimTx = client.claim({ claimData, from: '0x...' });
 const claim = await ethSigner.sendTransaction(claimTx);
 ```
 
@@ -166,22 +173,18 @@ const deposits = await tracker.getAllDepositsFor('0x...');
 
 for (const deposit of deposits) {
   console.log('Request ID:', deposit.requestId);
-  console.log('Direction:', deposit.deposit.chain === 'sourceChain' ? 'ETH → Pod' : 'Pod → ETH');
-  console.log('From:', deposit.deposit.depositor);
-  console.log('To:', deposit.deposit.destination);
+  console.log('Direction:', deposit.deposit.chain === 'sourceChain' ? 'ETH -> Pod' : 'Pod -> ETH');
   console.log('Token:', deposit.deposit.token);
   console.log('Amount:', deposit.deposit.amount);
-  console.log('Claimed:', deposit.isClaimed);
-  console.log('Claimable:', deposit.isClaimable);
+  console.log('Timestamp:', new Date(deposit.deposit.timestamp * 1000).toISOString());
+  console.log('Status:', deposit.isClaimed ? 'Claimed' : (deposit.isClaimable ? 'Claimable' : 'Pending'));
 }
 
-// Get deposits sent by address
+// Get deposits sent/received by address
 const sent = await tracker.getDepositsSentBy('0x...');
-
-// Get deposits received by address  
 const received = await tracker.getDepositsReceivedBy('0x...');
 
-// Check if deposit can be claimed (Pod → ETH only)
+// Check if deposit can be claimed
 const canClaim = await tracker.canBeClaimed(deposit);
 
 // Batch check processed status
@@ -192,38 +195,56 @@ const statuses = await tracker.areRequestsProcessed(deposits);
 
 ### SourceChainToPodActionClient
 
-For ETH → Pod deposits (auto-claim on Pod).
+For ETH -> Pod deposits (auto-claim on Pod).
 
 ```typescript
-// Deposit ERC20 tokens
 deposit(args: {
   token: string;
   amount: string | bigint;
   destinationWalletAddress: string;
+  callContract?: string;           // Contract to call on Pod after deposit (default: address(0))
+  reserveBalance?: string | bigint; // Amount to reserve when using callContract (default: 0)
   from?: string;
+  permit?: string;                 // Optional ERC20 permit bytes (default: '0x')
 }): UnsignedTransaction
 ```
 
 ### PodToSourceChainActionClient
 
-For Pod → ETH deposits and claims.
+For Pod -> ETH deposits and claims.
 
 ```typescript
-// Deposit ERC20 tokens on Pod
+// Deposit tokens on Pod
 deposit(args: {
-  token: string;
-  amount: string | bigint;
+  token: string;                    // Use 0xEeee...EEeE for native token
+  amount: string | bigint;          // Use ETH-side decimals
   destinationWalletAddress: string;
+  callContract?: string;            // Contract to call after deposit (default: address(0))
+  reserveBalance?: string | bigint; // Amount to reserve when using callContract (default: 0)
+  permit?: string;                  // Optional permit bytes (default: '0x')
   from?: string;
 }): UnsignedTransaction
 
-// Claim on ETH with aggregated signatures
+// Claim on ETH with proof
 claim(args: {
   claimData: ClaimProofData;
   from?: string;
 }): UnsignedTransaction
 ```
 
+### getBridgeClaimProof
+
+Helper to call `pod_getBridgeClaimProof` RPC and format the result.
+
+```typescript
+import { getBridgeClaimProof } from '@tapforce/pod-bridge-sdk';
+
+const { proof, committeeEpoch, auxTxSuffix } = await getBridgeClaimProof(
+  podProvider,      // ethers.JsonRpcProvider connected to Pod RPC
+  depositTxHash     // TX hash of the deposit on Pod
+);
+```
+
 ### PodBridgeTrackerClient
 
 ```typescript
@@ -236,12 +257,24 @@ areRequestsProcessed(deposits: BridgeRequest[]): Promise<boolean[]>
 
 ## Types
 
+### ClaimProofData
+
+```typescript
+interface ClaimProofData {
+  ethTokenAddress: string;  // Token address on ETH (different from Pod)
+  amount: string | bigint;  // Must match deposited amount
+  to: string;               // Recipient address
+  proof: string;            // Hex bytes from pod_getBridgeClaimProof
+  auxTxSuffix: string;      // Hex bytes from pod_getBridgeClaimProof
+}
+```
+
 ### BridgeRequest
 
 ```typescript
 interface BridgeRequest {
   requestId: string;
-  
+
   deposit: {
     chain: 'sourceChain' | 'pod';
     txHash: string;
@@ -249,11 +282,13 @@ interface BridgeRequest {
     destination: string;
     token: string;
     amount: string;
+    callContract?: string;   // Contract called after deposit (address(0) for simple bridge)
+    reserveBalance?: string; // Amount reserved when using callContract ('0' for simple bridge)
     chainId: number;
     blockNumber: number;
-    timestamp: number;
+    timestamp: number;       // Unix timestamp (seconds)
   };
-  
+
   claim?: {
     chain: 'sourceChain' | 'pod';
     txHash: string;
@@ -262,99 +297,40 @@ interface BridgeRequest {
     blockNumber: number;
     timestamp: number;
   };
-  
+
   isClaimed: boolean;
   isClaimable: boolean;
 }
 ```
 
-### ClaimProofData
-
-```typescript
-interface ClaimProofData {
-  ethTokenAddress: string;       // Token address on ETH (different from Pod)
-  amount: string | bigint;       // Same amount as deposited
-  to: string;                    // Recipient address
-  committeeEpoch: number;        // Hardcoded to 0 for now
-  aggregatedSignatures: string;  // Concatenated 65-byte ECDSA signatures (r,s,v)
-  depositTxHash: string;         // Deposit TX hash from Pod
-}
-```
-
-### Signature Recovery Helpers
-
-Pod returns DER-encoded 64-byte signatures without the parity bit (v), but the ETH contract requires 65-byte (r,s,v) format.
-The SDK handles this by trying both v values (27/28) and verifying against the committee's validator public keys.
-
-```typescript
-import { 
-  extractAggregatedSignaturesWithValidators,
-  extractAggregatedSignatures,
-  parseDerSignature,
-  addressFromPublicKey,
-  recoverSignatureWithoutPubkey
-} from '@tapforce/pod-bridge-sdk';
-
-// Recommended: Extract with validator verification (correct v-values)
-const podReceipt = await podProvider.send('eth_getTransactionReceipt', [depositTxHash]);
-const committee = await podProvider.send('pod_getCommittee', {});
-const aggregatedSignatures = extractAggregatedSignaturesWithValidators(
-  podReceipt,
-  committee.validators  // [[index, compressedPubKey], ...]
-);
-
-// Alternative: Extract without validator verification (may have wrong v-values)
-const sigs = extractAggregatedSignatures(podReceipt);
-
-// Low-level: Parse DER signature to r,s components
-const { r, s } = parseDerSignature(derEncodedSig);
-
-// Low-level: Recover 65-byte signature without pubkey (tries v=27 first)
-const sig65 = recoverSignatureWithoutPubkey(r, s, msgHash);
+## Events
 
-// Utility: Derive address from uncompressed public key
-const address = addressFromPublicKey(uncompressedPubKey);
-```
+The bridge contracts emit different events per chain (id type differs):
 
-#### Pod Receipt Format
+```solidity
+// ETH (Source Chain)
+event Deposit(uint256 indexed id, address indexed from, address indexed to, address token, uint256 amount, address callContract, uint256 reserveBalance);
+event Claim(bytes32 indexed txHash, address token, address mirrorToken, uint256 amount, address indexed to);
 
-```typescript
-interface PodTransactionReceipt {
-  // ... standard fields ...
-  attested_tx: {
-    hash: string;           // Hash signed by validators
-    committee_epoch: number;
-  };
-  signatures: {
-    "0": string;  // DER-encoded signature from validator 0
-    "1": string;  // DER-encoded signature from validator 1
-    // ...
-  };
-}
+// Pod
+event Deposit(bytes32 indexed id, address indexed from, address indexed to, address token, uint256 amount, address callContract, uint256 reserveBalance);
 ```
 
-#### Committee Format
+## ABIs
 
-```typescript
-// pod_getCommittee response
-{
-  validators: [
-    [0, "024ee7..."],  // [index, compressed_secp256k1_pubkey]
-    [1, "025c59..."],
-    // ...
-  ],
-  quorum_size: 3
-}
-```
+The SDK exports separate ABIs for each chain:
 
-## Events
+- `SOURCE_CHAIN_BRIDGE_ABI` - ETH bridge (6-param deposit with callContract/reserveBalance/permit, claim with proof)
+- `POD_BRIDGE_ABI` - Pod bridge (6-param deposit, bytes32 id events)
+- `BRIDGE_ABI` - Alias for `SOURCE_CHAIN_BRIDGE_ABI`
 
-The bridge contract emits:
+## Pod-specific Notes
 
-```solidity
-event Deposit(bytes32 indexed id, address indexed from, address indexed to, address token, uint256 amount);
-event Claim(bytes32 indexed id, address indexed to, address token, uint256 amount);
-```
+- Pod system contract address: `0x0000000000000000000000000000000000B41D9E`
+- Pod transactions are free: use `maxFeePerGas: 0, maxPriorityFeePerGas: 0, gasLimit: 0`
+- Must use EIP-1559 (type 2) transactions, not legacy `gasPrice`
+- Pod does NOT need `value` set for native token deposits - the system contract handles balance internally
+- Pod returns `blockNumber` as a Unix timestamp in receipts
 
 ## Development
 

package/dist/clients/action/pod-to-source-chain-client.d.ts

@@ -2,35 +2,37 @@ import { UnsignedTransaction, ClaimProofData, PodBridgeActionsClientConfig } fro
 /**
  * PodToSourceChainActionClient - Handles Pod -> ETH bridging
  *
- * New architecture:
- * - User deposits ERC20 tokens on Pod
- * - Wait for TX receipt from Pod
- * - User claims on ETH with aggregated validator signatures
- * - Only ERC20 tokens supported (no native tokens)
+ * - User deposits tokens on Pod
+ * - Call pod_getBridgeClaimProof(depositTxHash) to get proof
+ * - User claims on ETH with proof + auxTxSuffix
  *
  * Important notes:
- * - Token addresses on Pod and ETH are different (user deposits AAAA on Pod, claims BBBB on ETH)
- * - committee_epoch is hardcoded to 0 for now
- * - aggregated_signatures is concatenation of 65-byte ECDSA signatures (r,s,v)
- * - proof is the deposit TX hash (subject to change in the future)
+ * - Token addresses on Pod and ETH are different (deposit AAAA on Pod, claim BBBB on ETH)
+ * - For USDC-like tokens, use ETH-side decimals (e.g. parseUnits('1', 6) for USDC)
+ * - Pod system contract handles balance internally - do NOT set tx value
  */
 export declare class PodToSourceChainActionClient {
     private readonly config;
-    private readonly iface;
+    private readonly podIface;
+    private readonly sourceChainIface;
     constructor(config: PodBridgeActionsClientConfig);
     /**
-     * Create unsigned transaction for depositing ERC20 tokens from Pod to ETH
+     * Create unsigned transaction for depositing tokens from Pod to ETH
      *
      * After deposit:
-     * - Get the TX receipt from Pod
-     * - Call claim() on ETH with aggregated validator signatures
+     * - Call pod_getBridgeClaimProof(depositTxHash) on Pod RPC
+     * - Call claim() on ETH with the proof
      *
-     * Note: Native tokens are not supported. Only ERC20.
-     * Note: Token addresses differ between Pod and ETH chains.
+     * Note: Pod system contract handles balance deduction internally.
+     * Do NOT set transaction value - even for native token (0xEeee...EEeE) deposits.
+     * Use ETH-side decimals for amount (e.g. 1e6 for 1 USDC, not 1e18).
      *
-     * @param args.token Token address on Pod to deposit
-     * @param args.amount Amount to deposit (in wei)
+     * @param args.token Token address on Pod to deposit (use 0xEeee...EEeE for native)
+     * @param args.amount Amount to deposit (in ETH-side decimals)
      * @param args.destinationWalletAddress Recipient address on ETH
+     * @param args.callContract Optional: contract to call after deposit (default: address(0) for simple bridge)
+     * @param args.reserveBalance Optional: amount to keep as reserve when using callContract (default: 0)
+     * @param args.permit Optional permit bytes (default '0x')
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded deposit call
      */
@@ -38,15 +40,18 @@ export declare class PodToSourceChainActionClient {
         token: string;
         amount: string | bigint;
         destinationWalletAddress: string;
+        callContract?: string;
+        reserveBalance?: string | bigint;
+        permit?: string;
         from?: string;
     }): UnsignedTransaction;
     /**
-     * Create unsigned transaction for claiming ERC20 tokens on ETH (source chain)
+     * Create unsigned transaction for claiming tokens on ETH (source chain)
      *
-     * This is called after depositing on Pod and getting the TX receipt.
-     * The aggregated_signatures must be recovered to 65-byte format (r,s,v).
+     * This is called after depositing on Pod and obtaining the claim proof
+     * via pod_getBridgeClaimProof RPC (or the getBridgeClaimProof helper).
      *
-     * @param args.claimData Claim proof data with aggregated signatures
+     * @param args.claimData Claim proof data with proof + auxTxSuffix
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded claim call
      */

package/dist/clients/action/pod-to-source-chain-client.js

@@ -6,44 +6,49 @@ const bridge_abi_1 = require("../../libs/abi/bridge.abi");
 /**
  * PodToSourceChainActionClient - Handles Pod -> ETH bridging
  *
- * New architecture:
- * - User deposits ERC20 tokens on Pod
- * - Wait for TX receipt from Pod
- * - User claims on ETH with aggregated validator signatures
- * - Only ERC20 tokens supported (no native tokens)
+ * - User deposits tokens on Pod
+ * - Call pod_getBridgeClaimProof(depositTxHash) to get proof
+ * - User claims on ETH with proof + auxTxSuffix
  *
  * Important notes:
- * - Token addresses on Pod and ETH are different (user deposits AAAA on Pod, claims BBBB on ETH)
- * - committee_epoch is hardcoded to 0 for now
- * - aggregated_signatures is concatenation of 65-byte ECDSA signatures (r,s,v)
- * - proof is the deposit TX hash (subject to change in the future)
+ * - Token addresses on Pod and ETH are different (deposit AAAA on Pod, claim BBBB on ETH)
+ * - For USDC-like tokens, use ETH-side decimals (e.g. parseUnits('1', 6) for USDC)
+ * - Pod system contract handles balance internally - do NOT set tx value
  */
 class PodToSourceChainActionClient {
     constructor(config) {
         this.config = config;
-        this.iface = new ethers_1.Interface(bridge_abi_1.BRIDGE_ABI);
+        this.podIface = new ethers_1.Interface(bridge_abi_1.POD_BRIDGE_ABI);
+        this.sourceChainIface = new ethers_1.Interface(bridge_abi_1.SOURCE_CHAIN_BRIDGE_ABI);
     }
     /**
-     * Create unsigned transaction for depositing ERC20 tokens from Pod to ETH
+     * Create unsigned transaction for depositing tokens from Pod to ETH
      *
      * After deposit:
-     * - Get the TX receipt from Pod
-     * - Call claim() on ETH with aggregated validator signatures
+     * - Call pod_getBridgeClaimProof(depositTxHash) on Pod RPC
+     * - Call claim() on ETH with the proof
      *
-     * Note: Native tokens are not supported. Only ERC20.
-     * Note: Token addresses differ between Pod and ETH chains.
+     * Note: Pod system contract handles balance deduction internally.
+     * Do NOT set transaction value - even for native token (0xEeee...EEeE) deposits.
+     * Use ETH-side decimals for amount (e.g. 1e6 for 1 USDC, not 1e18).
      *
-     * @param args.token Token address on Pod to deposit
-     * @param args.amount Amount to deposit (in wei)
+     * @param args.token Token address on Pod to deposit (use 0xEeee...EEeE for native)
+     * @param args.amount Amount to deposit (in ETH-side decimals)
      * @param args.destinationWalletAddress Recipient address on ETH
+     * @param args.callContract Optional: contract to call after deposit (default: address(0) for simple bridge)
+     * @param args.reserveBalance Optional: amount to keep as reserve when using callContract (default: 0)
+     * @param args.permit Optional permit bytes (default '0x')
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded deposit call
      */
     deposit(args) {
-        const data = this.iface.encodeFunctionData('deposit', [
+        const data = this.podIface.encodeFunctionData('deposit', [
             args.token,
             args.amount,
-            args.destinationWalletAddress
+            args.destinationWalletAddress,
+            args.callContract ?? ethers_1.ZeroAddress,
+            args.reserveBalance ?? 0,
+            args.permit ?? '0x',
         ]);
         return {
             to: this.config.pod.contractAddress,
@@ -53,24 +58,23 @@ class PodToSourceChainActionClient {
         };
     }
     /**
-     * Create unsigned transaction for claiming ERC20 tokens on ETH (source chain)
+     * Create unsigned transaction for claiming tokens on ETH (source chain)
      *
-     * This is called after depositing on Pod and getting the TX receipt.
-     * The aggregated_signatures must be recovered to 65-byte format (r,s,v).
+     * This is called after depositing on Pod and obtaining the claim proof
+     * via pod_getBridgeClaimProof RPC (or the getBridgeClaimProof helper).
      *
-     * @param args.claimData Claim proof data with aggregated signatures
+     * @param args.claimData Claim proof data with proof + auxTxSuffix
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded claim call
      */
     claim(args) {
-        const { ethTokenAddress, amount, to, committeeEpoch, aggregatedSignatures, depositTxHash } = args.claimData;
-        const data = this.iface.encodeFunctionData('claim', [
+        const { ethTokenAddress, amount, to, proof, auxTxSuffix } = args.claimData;
+        const data = this.sourceChainIface.encodeFunctionData('claim', [
             ethTokenAddress,
             amount,
             to,
-            committeeEpoch,
-            aggregatedSignatures,
-            depositTxHash
+            proof,
+            auxTxSuffix
         ]);
         return {
             to: this.config.sourceChain.contractAddress,