@tapforce/pod-bridge-sdk 1.0.1 → 1.1.0

package/README.md

@@ -34,7 +34,8 @@ pnpm add @tapforce/pod-bridge-sdk
 
 ```typescript
 import { 
-  PodBridgeActionClient, 
+  BridgedToPodActionClient,
+  PodToBridgedActionClient,
   PodBridgeTrackerClient,
   PodBridgeConfig 
 } from '@tapforce/pod-bridge-sdk';
@@ -46,11 +47,11 @@ Create a configuration object with source and destination chain details:
 
 ```typescript
 const config: PodBridgeConfig = {
-  source: {
+  bridged: {
     rpcUrl: 'https://sepolia.infura.io/v3/YOUR_KEY',
     contractAddress: '0x...' // Source chain bridge contract
   },
-  destination: {
+  pod: {
     rpcUrl: 'https://pod-rpc.example.com',
     contractAddress: '0x...' // Destination chain bridge contract
   }
@@ -59,94 +60,109 @@ const config: PodBridgeConfig = {
 
 ## Usage
 
-### 1. Action Client - Creating Transactions
+### 1. Action Clients - Creating Transactions
 
-The `PodBridgeActionClient` creates unsigned transactions that you can sign and broadcast.
+The SDK provides two action clients for different bridge directions:
 
-#### Deposit ERC20 Tokens
+- **`BridgedToPodActionClient`**: For Bridged → POD transfers (e.g., Sepolia → POD)
+- **`PodToBridgedActionClient`**: For POD → Bridged transfers (e.g., POD → Sepolia)
+
+#### Configuration for Action Clients
 
 ```typescript
-const actionClient = new PodBridgeActionClient();
+const actionConfig = {
+  bridged: {
+    contractAddress: '0x...' // Bridged chain bridge contract (e.g., Sepolia)
+  },
+  pod: {
+    contractAddress: '0x...' // POD chain bridge contract
+  }
+};
+
+const bridgedToPodClient = new BridgedToPodActionClient(actionConfig);
+const podToBridgedClient = new PodToBridgedActionClient(actionConfig);
+```
+
+#### Deposit from Bridged Chain (e.g., Sepolia → POD)
 
-// Create unsigned transaction for ERC20 deposit
-const unsignedTx = actionClient.depositToken({
+```typescript
+// Create unsigned transaction for ERC20 deposit on Bridged chain
+const unsignedTx = bridgedToPodClient.depositToken({
   token: '0x...', // ERC20 token address
   amount: '1000000000000000000', // Amount in wei (1 token with 18 decimals)
-  recipient: '0x...', // Recipient address on destination chain
-  contractAddress: config.source.contractAddress,
+  destinationWalletAddress: '0x...', // Recipient address on POD
   from: '0x...' // Optional: sender address
 });
 
-// Sign and send transaction using your wallet/provider
-// const tx = await signer.sendTransaction(unsignedTx);
-```
-
-#### Deposit Native Tokens (ETH)
-
-```typescript
-// Create unsigned transaction for native token deposit
-const unsignedTx = actionClient.depositNative({
+// Deposit native tokens
+const unsignedNativeTx = bridgedToPodClient.depositNative({
   amount: '1000000000000000000', // Amount in wei (1 ETH)
-  recipient: '0x...', // Recipient address on destination chain
-  contractAddress: config.source.contractAddress,
+  destinationWalletAddress: '0x...', // Recipient address on POD
   from: '0x...' // Optional: sender address
 });
 
-// Sign and send transaction
+// Sign and send transaction using your wallet/provider
 // const tx = await signer.sendTransaction(unsignedTx);
 ```
 
-#### Claim Tokens (with Certificate) - Sepolia from POD
+#### Claim on POD from Bridged Chain Deposits
 
-For claiming on Sepolia from POD deposits, use certificate-based claims:
+For claiming on POD from Bridged chain deposits, use block number-based claims:
 
 ```typescript
-// Obtain certified log from POD certificate system
-const certifiedLog = {
-  log: {
-    addr: '0x...',
-    topics: ['0x...'],
-    data: '0x...'
-  },
-  sigs: [
-    { r: '0x...', s: '0x...', v: 27 }
-  ]
-};
-
-// Create unsigned claim transaction for ERC20
-const unsignedTx = actionClient.claimWithCertificate({
-  certifiedLog,
-  contractAddress: config.destination.contractAddress,
+// Create unsigned claim transaction for ERC20 on POD
+const unsignedTx = bridgedToPodClient.claimWithBlockNumber({
+  id: '123', // Request ID from deposit event
+  token: '0x...', // Token address on source chain
+  blockNumber: 12345678, // Block number of deposit on source chain
   from: '0x...' // Optional: claimer address
 });
 
 // For native tokens
-const unsignedNativeTx = actionClient.claimNativeWithCertificate({
-  certifiedLog,
-  contractAddress: config.destination.contractAddress,
+const unsignedNativeTx = bridgedToPodClient.claimNativeWithBlockNumber({
+  id: '123',
+  blockNumber: 12345678,
   from: '0x...'
 });
 ```
 
-#### Claim Tokens (with Block Number) - POD from Sepolia
+#### Deposit from POD (POD → Bridged Chain)
 
-For claiming on POD from Sepolia deposits, use block number-based claims:
+```typescript
+// Create unsigned transaction for ERC20 deposit on POD
+const unsignedTx = podToBridgedClient.depositToken({
+  token: '0x...', // ERC20 token address
+  amount: '1000000000000000000', // Amount in wei
+  destinationWalletAddress: '0x...', // Recipient address on Bridged chain
+  from: '0x...' // Optional: sender address
+});
+
+// Deposit native tokens
+const unsignedNativeTx = podToBridgedClient.depositNative({
+  amount: '1000000000000000000',
+  destinationWalletAddress: '0x...',
+  from: '0x...'
+});
+```
+
+#### Claim on Bridged Chain from POD Deposits
+
+For claiming on Bridged chain from POD deposits, use certificate-based claims. First, get the certified log from the POD deposit transaction:
 
 ```typescript
-// Create unsigned claim transaction for ERC20
-const unsignedTx = actionClient.claimWithBlockNumber({
-  id: '123', // Request ID from deposit event
-  token: '0x...', // Token address on source chain
-  blockNumber: 12345678, // Block number of deposit on source chain
-  contractAddress: config.destination.contractAddress,
+// Get certified log from POD deposit transaction
+const depositTxHash = '0x...'; // Transaction hash of deposit on POD
+const certifiedLog = await trackerClient.getDepositCertifiedLog(depositTxHash);
+
+// Create unsigned claim transaction for ERC20 on Bridged chain
+const unsignedTx = podToBridgedClient.claimWithCertificate({
+  certifiedLog,
   from: '0x...' // Optional: claimer address
 });
 
 // For native tokens
-const unsignedNativeTx = actionClient.claimNativeWithBlockNumber({
-  id: '123',
-  blockNumber: 12345678,
-  contractAddress: config.destination.contractAddress,
+const unsignedNativeTx = podToBridgedClient.claimNativeWithCertificate({
+  certifiedLog,
   from: '0x...'
 });
 ```
@@ -232,44 +248,69 @@ processedStatuses.forEach((isProcessed, index) => {
 
 ## API Reference
 
-### PodBridgeActionClient
+### BridgedToPodActionClient
+
+Handles transactions for Bridged → POD direction.
+
+#### Constructor
+
+```typescript
+new BridgedToPodActionClient(config: PodBridgeActionsClientConfig)
+```
 
 #### Methods
 
-- **`depositToken(args)`**: Create unsigned transaction for ERC20 deposit
+- **`depositToken(args)`**: Create unsigned transaction for ERC20 deposit on Bridged chain
   - `token`: Token address
   - `amount`: Amount in wei (string | bigint)
-  - `recipient`: Recipient address on destination chain
-  - `contractAddress`: Bridge contract address
+  - `destinationWalletAddress`: Recipient address on POD
   - `from?`: Optional sender address
 
-- **`depositNative(args)`**: Create unsigned transaction for native token deposit
+- **`depositNative(args)`**: Create unsigned transaction for native token deposit on Bridged chain
   - `amount`: Amount in wei (string | bigint)
-  - `recipient`: Recipient address on destination chain
-  - `contractAddress`: Bridge contract address
+  - `destinationWalletAddress`: Recipient address on POD
   - `from?`: Optional sender address
 
-- **`claimWithCertificate(args)`**: Create unsigned transaction for claiming with certificate
-  - `certifiedLog`: Certified log from POD certificate system
-  - `contractAddress`: Bridge contract address
+- **`claimWithBlockNumber(args)`**: Create unsigned transaction for claiming on POD with block number
+  - `id`: Request ID
+  - `token`: Token address
+  - `blockNumber`: Block number of deposit on Bridged chain
   - `from?`: Optional claimer address
 
-- **`claimNativeWithCertificate(args)`**: Create unsigned transaction for claiming native tokens with certificate
-  - `certifiedLog`: Certified log from POD certificate system
-  - `contractAddress`: Bridge contract address
+- **`claimNativeWithBlockNumber(args)`**: Create unsigned transaction for claiming native tokens on POD with block number
+  - `id`: Request ID
+  - `blockNumber`: Block number of deposit on Bridged chain
   - `from?`: Optional claimer address
 
-- **`claimWithBlockNumber(args)`**: Create unsigned transaction for claiming with block number
-  - `id`: Request ID
+### PodToBridgedActionClient
+
+Handles transactions for POD → Bridged direction.
+
+#### Constructor
+
+```typescript
+new PodToBridgedActionClient(config: PodBridgeActionsClientConfig)
+```
+
+#### Methods
+
+- **`depositToken(args)`**: Create unsigned transaction for ERC20 deposit on POD
   - `token`: Token address
-  - `blockNumber`: Block number of deposit
-  - `contractAddress`: Bridge contract address
+  - `amount`: Amount in wei (string | bigint)
+  - `destinationWalletAddress`: Recipient address on Bridged chain
+  - `from?`: Optional sender address
+
+- **`depositNative(args)`**: Create unsigned transaction for native token deposit on POD
+  - `amount`: Amount in wei (string | bigint)
+  - `destinationWalletAddress`: Recipient address on Bridged chain
+  - `from?`: Optional sender address
+
+- **`claimWithCertificate(args)`**: Create unsigned transaction for claiming on Bridged chain with certificate
+  - `certifiedLog`: Certified log from POD certificate system
   - `from?`: Optional claimer address
 
-- **`claimNativeWithBlockNumber(args)`**: Create unsigned transaction for claiming native tokens with block number
-  - `id`: Request ID
-  - `blockNumber`: Block number of deposit
-  - `contractAddress`: Bridge contract address
+- **`claimNativeWithCertificate(args)`**: Create unsigned transaction for claiming native tokens on Bridged chain with certificate
+  - `certifiedLog`: Certified log from POD certificate system
   - `from?`: Optional claimer address
 
 ### PodBridgeTrackerClient
@@ -291,6 +332,10 @@ processedStatuses.forEach((isProcessed, index) => {
 - **`areRequestsProcessed(deposits)`**: Batch check if requests are processed
   - Returns: `Promise<boolean[]>`
 
+- **`getDepositCertifiedLog(txHash)`**: Get certified log for claiming on Sepolia from POD deposit
+  - `txHash`: Transaction hash of deposit on POD
+  - Returns: `Promise<CertifiedLog>` with attestations and merkle proof
+
 ## Types
 
 ### BridgeRequest
@@ -334,11 +379,18 @@ interface CertifiedLog {
     topics: string[];
     data: string;
   };
-  sigs: Array<{
-    r: string;
-    s: string;
-    v: number;
-  }>;
+  logIndex: bigint | string;
+  certificate: {
+    leaf: string;
+    certifiedReceipt: {
+      receiptRoot: string;
+      aggregateSignature: string;
+      sortedAttestationTimestamps: bigint[] | string[];
+    };
+    proof: {
+      path: string[];
+    };
+  };
 }
 ```
 
@@ -358,65 +410,125 @@ The SDK supports two bridge implementations:
 
 ## Examples
 
-### Complete Deposit and Claim Flow
+### Complete Deposit and Claim Flow (Sepolia → POD)
 
 ```typescript
 import { ethers } from 'ethers';
-import { PodBridgeActionClient, PodBridgeTrackerClient } from '@tapforce/pod-bridge-sdk';
+import { BridgedToPodActionClient, PodBridgeTrackerClient } from '@tapforce/pod-bridge-sdk';
 
 // Setup
-const config = {
-  source: {
+const trackerConfig = {
+  bridged: {
     rpcUrl: 'https://sepolia.infura.io/v3/YOUR_KEY',
-    contractAddress: '0xSourceBridgeContract'
+    contractAddress: '0xSepoliaBridgeContract'
   },
-  destination: {
-    rpcUrl: 'https://pod-rpc.example.com',
-    contractAddress: '0xDestBridgeContract'
+  pod: {
+    rpcUrl: 'https://rpc.v1.dev.pod.network',
+    contractAddress: '0xPodBridgeContract'
   }
 };
 
-const actionClient = new PodBridgeActionClient();
-const trackerClient = new PodBridgeTrackerClient(config);
-const provider = new ethers.JsonRpcProvider(config.source.rpcUrl);
-const signer = new ethers.Wallet('PRIVATE_KEY', provider);
+const actionConfig = {
+  bridged: { contractAddress: '0xSepoliaBridgeContract' },
+  pod: { contractAddress: '0xPodBridgeContract' }
+};
 
-// Step 1: Deposit tokens
+const actionClient = new BridgedToPodActionClient(actionConfig);
+const trackerClient = new PodBridgeTrackerClient(trackerConfig);
+const sepoliaProvider = new ethers.JsonRpcProvider(trackerConfig.bridged.rpcUrl);
+const sepoliaSigner = new ethers.Wallet('PRIVATE_KEY', sepoliaProvider);
+
+// Step 1: Deposit tokens on Sepolia
 const depositTx = actionClient.depositToken({
   token: '0xTokenAddress',
   amount: ethers.parseEther('10').toString(),
-  recipient: await signer.getAddress(),
-  contractAddress: config.source.contractAddress
+  destinationWalletAddress: await sepoliaSigner.getAddress()
 });
 
-const tx = await signer.sendTransaction(depositTx);
+const tx = await sepoliaSigner.sendTransaction(depositTx);
 await tx.wait();
 console.log(`Deposit tx: ${tx.hash}`);
 
 // Step 2: Track deposit
-const deposits = await trackerClient.getDepositsSentBy(await signer.getAddress());
+const deposits = await trackerClient.getDepositsSentBy(await sepoliaSigner.getAddress());
 const latestDeposit = deposits[0];
 
 console.log(`Request ID: ${latestDeposit.requestId}`);
 console.log(`Amount: ${ethers.formatEther(latestDeposit.amount)}`);
 
-// Step 3: Wait for finality and claim
+// Step 3: Wait for finality and claim on POD
 const canClaim = await trackerClient.canBeClaimed(latestDeposit);
 if (canClaim) {
   const claimTx = actionClient.claimWithBlockNumber({
     id: latestDeposit.requestId,
     token: latestDeposit.token,
-    blockNumber: latestDeposit.blockNumber,
-    contractAddress: config.destination.contractAddress
+    blockNumber: latestDeposit.blockNumber
   });
   
-  // Submit claim on destination chain
-  // const destSigner = new ethers.Wallet('PRIVATE_KEY', destProvider);
-  // const claim = await destSigner.sendTransaction(claimTx);
-  // await claim.wait();
+  // Submit claim on POD
+  const podProvider = new ethers.JsonRpcProvider(trackerConfig.pod.rpcUrl);
+  const podSigner = new ethers.Wallet('PRIVATE_KEY', podProvider);
+  const claim = await podSigner.sendTransaction(claimTx);
+  await claim.wait();
+  console.log(`Claimed on POD: ${claim.hash}`);
 }
 ```
 
+### Complete Deposit and Claim Flow (POD → Sepolia)
+
+```typescript
+import { ethers } from 'ethers';
+import { PodToBridgedActionClient, PodBridgeTrackerClient } from '@tapforce/pod-bridge-sdk';
+
+// Setup
+const trackerConfig = {
+  bridged: {
+    rpcUrl: 'https://sepolia.infura.io/v3/YOUR_KEY',
+    contractAddress: '0xSepoliaBridgeContract'
+  },
+  pod: {
+    rpcUrl: 'https://rpc.v1.dev.pod.network',
+    contractAddress: '0xPodBridgeContract'
+  }
+};
+
+const actionConfig = {
+  bridged: { contractAddress: '0xSepoliaBridgeContract' },
+  pod: { contractAddress: '0xPodBridgeContract' }
+};
+
+const actionClient = new PodToBridgedActionClient(actionConfig);
+const trackerClient = new PodBridgeTrackerClient(trackerConfig);
+const podProvider = new ethers.JsonRpcProvider(trackerConfig.pod.rpcUrl);
+const podSigner = new ethers.Wallet('PRIVATE_KEY', podProvider);
+
+// Step 1: Deposit tokens on POD
+const depositTx = actionClient.depositToken({
+  token: '0xTokenAddress',
+  amount: ethers.parseEther('10').toString(),
+  destinationWalletAddress: await podSigner.getAddress()
+});
+
+const tx = await podSigner.sendTransaction(depositTx);
+const receipt = await tx.wait();
+console.log(`Deposit tx on POD: ${tx.hash}`);
+
+// Step 2: Get certified log from POD transaction
+const certifiedLog = await trackerClient.getDepositCertifiedLog(tx.hash);
+console.log('Got certified log with attestations');
+
+// Step 3: Claim on Sepolia using certified log
+const claimTx = actionClient.claimWithCertificate({
+  certifiedLog
+});
+
+const sepoliaProvider = new ethers.JsonRpcProvider(trackerConfig.bridged.rpcUrl);
+const sepoliaSigner = new ethers.Wallet('PRIVATE_KEY', sepoliaProvider);
+const claim = await sepoliaSigner.sendTransaction(claimTx);
+await claim.wait();
+console.log(`Claimed on Sepolia: ${claim.hash}`);
+```
+
 ## Development
 
 ### Build

package/dist/clients/action/{client.d.ts → bridged-to-pod-client.d.ts}

@@ -1,12 +1,13 @@
-import { UnsignedTransaction, CertifiedLog } from "../../libs/types/pod-bridge.types";
-export declare class PodBridgeActionClient {
+import { UnsignedTransaction, PodBridgeActionsClientConfig } from "../../libs/types/pod-bridge.types";
+export declare class BridgedToPodActionClient {
+    private readonly config;
     private readonly iface;
-    constructor();
+    constructor(config: PodBridgeActionsClientConfig);
     /**
      * Create unsigned transaction for depositing ERC20 tokens
      * @param args.token Token address to deposit
      * @param args.amount Amount to deposit (in wei)
-     * @param args.recipient Recipient address on destination chain
+     * @param args.destinationWalletAddress Recipient address on destination chain
      * @param args.contractAddress Bridge contract address (source chain)
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded deposit call
@@ -14,48 +15,20 @@ export declare class PodBridgeActionClient {
     depositToken(args: {
         token: string;
         amount: string | bigint;
-        recipient: string;
-        contractAddress: string;
+        destinationWalletAddress: string;
         from?: string;
     }): UnsignedTransaction;
     /**
      * Create unsigned transaction for depositing native tokens (ETH)
      * @param args.amount Amount to deposit (in wei) - also set as transaction value
-     * @param args.recipient Recipient address on destination chain
+     * @param args.destinationWalletAddress Recipient address on destination chain
      * @param args.contractAddress Bridge contract address (source chain)
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded depositNative call
      */
     depositNative(args: {
         amount: string | bigint;
-        recipient: string;
-        contractAddress: string;
-        from?: string;
-    }): UnsignedTransaction;
-    /**
-     * Create unsigned transaction for claiming tokens (BridgeDepositWithdraw - with certificates)
-     * Used for claiming on Sepolia from POD deposits
-     * @param args.certifiedLog Certified log from POD certificate system
-     * @param args.contractAddress Bridge contract address (destination chain)
-     * @param args.from Optional sender address
-     * @returns Unsigned transaction template with encoded claim call
-     */
-    claimWithCertificate(args: {
-        certifiedLog: CertifiedLog;
-        contractAddress: string;
-        from?: string;
-    }): UnsignedTransaction;
-    /**
-     * Create unsigned transaction for claiming native tokens (BridgeDepositWithdraw - with certificates)
-     * Used for claiming native tokens on Sepolia from POD deposits
-     * @param args.certifiedLog Certified log from POD certificate system
-     * @param args.contractAddress Bridge contract address (destination chain)
-     * @param args.from Optional sender address
-     * @returns Unsigned transaction template with encoded claimNative call
-     */
-    claimNativeWithCertificate(args: {
-        certifiedLog: CertifiedLog;
-        contractAddress: string;
+        destinationWalletAddress: string;
         from?: string;
     }): UnsignedTransaction;
     /**

package/dist/clients/action/{client.js → bridged-to-pod-client.js}

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PodBridgeActionClient = void 0;
+exports.BridgedToPodActionClient = void 0;
 const ethers_1 = require("ethers");
 const bridge_abi_1 = require("../../libs/abi/bridge.abi");
-class PodBridgeActionClient {
-    constructor() {
+class BridgedToPodActionClient {
+    constructor(config) {
+        this.config = config;
         this.iface = new ethers_1.Interface(bridge_abi_1.POD_BRIDGE_ABI);
     }
     /**
      * Create unsigned transaction for depositing ERC20 tokens
      * @param args.token Token address to deposit
      * @param args.amount Amount to deposit (in wei)
-     * @param args.recipient Recipient address on destination chain
+     * @param args.destinationWalletAddress Recipient address on destination chain
      * @param args.contractAddress Bridge contract address (source chain)
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded deposit call
@@ -20,10 +21,10 @@ class PodBridgeActionClient {
         const data = this.iface.encodeFunctionData('deposit', [
             args.token,
             args.amount,
-            args.recipient
+            args.destinationWalletAddress
         ]);
         return {
-            to: args.contractAddress,
+            to: this.config.bridged.contractAddress,
             data,
             value: '0',
             from: args === null || args === void 0 ? void 0 : args.from
@@ -32,54 +33,20 @@ class PodBridgeActionClient {
     /**
      * Create unsigned transaction for depositing native tokens (ETH)
      * @param args.amount Amount to deposit (in wei) - also set as transaction value
-     * @param args.recipient Recipient address on destination chain
+     * @param args.destinationWalletAddress Recipient address on destination chain
      * @param args.contractAddress Bridge contract address (source chain)
      * @param args.from Optional sender address
      * @returns Unsigned transaction template with encoded depositNative call
      */
     depositNative(args) {
-        const data = this.iface.encodeFunctionData('depositNative', [args.recipient]);
+        const data = this.iface.encodeFunctionData('depositNative', [args.destinationWalletAddress]);
         return {
-            to: args.contractAddress,
+            to: this.config.bridged.contractAddress,
             data,
             value: args.amount.toString(),
             from: args === null || args === void 0 ? void 0 : args.from
         };
     }
-    /**
-     * Create unsigned transaction for claiming tokens (BridgeDepositWithdraw - with certificates)
-     * Used for claiming on Sepolia from POD deposits
-     * @param args.certifiedLog Certified log from POD certificate system
-     * @param args.contractAddress Bridge contract address (destination chain)
-     * @param args.from Optional sender address
-     * @returns Unsigned transaction template with encoded claim call
-     */
-    claimWithCertificate(args) {
-        const data = this.iface.encodeFunctionData('claim', [args.certifiedLog]);
-        return {
-            to: args.contractAddress,
-            data,
-            value: '0',
-            from: args === null || args === void 0 ? void 0 : args.from
-        };
-    }
-    /**
-     * Create unsigned transaction for claiming native tokens (BridgeDepositWithdraw - with certificates)
-     * Used for claiming native tokens on Sepolia from POD deposits
-     * @param args.certifiedLog Certified log from POD certificate system
-     * @param args.contractAddress Bridge contract address (destination chain)
-     * @param args.from Optional sender address
-     * @returns Unsigned transaction template with encoded claimNative call
-     */
-    claimNativeWithCertificate(args) {
-        const data = this.iface.encodeFunctionData('claimNative', [args.certifiedLog]);
-        return {
-            to: args.contractAddress,
-            data,
-            value: '0',
-            from: args === null || args === void 0 ? void 0 : args.from
-        };
-    }
     /**
      * Create unsigned transaction for claiming tokens (BridgeMintBurn - using precompiles)
      * Used for claiming on POD from Sepolia deposits
@@ -97,7 +64,7 @@ class PodBridgeActionClient {
             args.blockNumber
         ]);
         return {
-            to: args.contractAddress,
+            to: this.config.pod.contractAddress,
             data,
             value: '0',
             from: args === null || args === void 0 ? void 0 : args.from
@@ -115,11 +82,11 @@ class PodBridgeActionClient {
     claimNativeWithBlockNumber(args) {
         const data = this.iface.encodeFunctionData('claimNative(uint256,uint256)', [args.id, args.blockNumber]);
         return {
-            to: args.contractAddress,
+            to: this.config.pod.contractAddress,
             data,
             value: '0',
             from: args === null || args === void 0 ? void 0 : args.from
         };
     }
 }
-exports.PodBridgeActionClient = PodBridgeActionClient;
+exports.BridgedToPodActionClient = BridgedToPodActionClient;

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

@@ -0,0 +1,54 @@
+import { UnsignedTransaction, CertifiedLog, PodBridgeActionsClientConfig } from "../../libs/types/pod-bridge.types";
+export declare class PodToBridgedActionClient {
+    private readonly config;
+    private readonly iface;
+    constructor(config: PodBridgeActionsClientConfig);
+    /**
+     * Create unsigned transaction for depositing ERC20 tokens from POD to Bridged chain
+     * @param args.token Token address to deposit
+     * @param args.amount Amount to deposit (in wei)
+     * @param args.destinationWalletAddress Recipient address on destination chain
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded deposit call
+     */
+    depositToken(args: {
+        token: string;
+        amount: string | bigint;
+        destinationWalletAddress: string;
+        from?: string;
+    }): UnsignedTransaction;
+    /**
+     * Create unsigned transaction for depositing native tokens from POD to Bridged chain
+     * @param args.amount Amount to deposit (in wei) - also set as transaction value
+     * @param args.destinationWalletAddress Recipient address on destination chain
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded depositNative call
+     */
+    depositNative(args: {
+        amount: string | bigint;
+        destinationWalletAddress: string;
+        from?: string;
+    }): UnsignedTransaction;
+    /**
+     * Create unsigned transaction for claiming tokens on Bridged chain (BridgeDepositWithdraw - with certificates)
+     * Used for claiming on Bridged chain from POD deposits
+     * @param args.certifiedLog Certified log from POD certificate system
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded claim call
+     */
+    claimWithCertificate(args: {
+        certifiedLog: CertifiedLog;
+        from?: string;
+    }): UnsignedTransaction;
+    /**
+     * Create unsigned transaction for claiming native tokens on Bridged chain (BridgeDepositWithdraw - with certificates)
+     * Used for claiming native tokens on Bridged chain from POD deposits
+     * @param args.certifiedLog Certified log from POD certificate system
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded claimNative call
+     */
+    claimNativeWithCertificate(args: {
+        certifiedLog: CertifiedLog;
+        from?: string;
+    }): UnsignedTransaction;
+}

package/dist/clients/action/pod-to-bridged-client.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodToBridgedActionClient = void 0;
+const ethers_1 = require("ethers");
+const bridge_abi_1 = require("../../libs/abi/bridge.abi");
+class PodToBridgedActionClient {
+    constructor(config) {
+        this.config = config;
+        this.iface = new ethers_1.Interface(bridge_abi_1.POD_BRIDGE_ABI);
+    }
+    /**
+     * Create unsigned transaction for depositing ERC20 tokens from POD to Bridged chain
+     * @param args.token Token address to deposit
+     * @param args.amount Amount to deposit (in wei)
+     * @param args.destinationWalletAddress Recipient address on destination chain
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded deposit call
+     */
+    depositToken(args) {
+        const data = this.iface.encodeFunctionData('deposit', [
+            args.token,
+            args.amount,
+            args.destinationWalletAddress
+        ]);
+        return {
+            to: this.config.pod.contractAddress,
+            data,
+            value: '0',
+            from: args === null || args === void 0 ? void 0 : args.from
+        };
+    }
+    /**
+     * Create unsigned transaction for depositing native tokens from POD to Bridged chain
+     * @param args.amount Amount to deposit (in wei) - also set as transaction value
+     * @param args.destinationWalletAddress Recipient address on destination chain
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded depositNative call
+     */
+    depositNative(args) {
+        const data = this.iface.encodeFunctionData('depositNative', [args.destinationWalletAddress]);
+        return {
+            to: this.config.pod.contractAddress,
+            data,
+            value: args.amount.toString(),
+            from: args === null || args === void 0 ? void 0 : args.from
+        };
+    }
+    /**
+     * Create unsigned transaction for claiming tokens on Bridged chain (BridgeDepositWithdraw - with certificates)
+     * Used for claiming on Bridged chain from POD deposits
+     * @param args.certifiedLog Certified log from POD certificate system
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded claim call
+     */
+    claimWithCertificate(args) {
+        const data = this.iface.encodeFunctionData('claim', [args.certifiedLog]);
+        return {
+            to: this.config.bridged.contractAddress,
+            data,
+            value: '0',
+            from: args === null || args === void 0 ? void 0 : args.from
+        };
+    }
+    /**
+     * Create unsigned transaction for claiming native tokens on Bridged chain (BridgeDepositWithdraw - with certificates)
+     * Used for claiming native tokens on Bridged chain from POD deposits
+     * @param args.certifiedLog Certified log from POD certificate system
+     * @param args.from Optional sender address
+     * @returns Unsigned transaction template with encoded claimNative call
+     */
+    claimNativeWithCertificate(args) {
+        const data = this.iface.encodeFunctionData('claimNative', [args.certifiedLog]);
+        return {
+            to: this.config.bridged.contractAddress,
+            data,
+            value: '0',
+            from: args === null || args === void 0 ? void 0 : args.from
+        };
+    }
+}
+exports.PodToBridgedActionClient = PodToBridgedActionClient;

package/dist/clients/tracker/client.d.ts

@@ -1,10 +1,10 @@
-import { PodBridgeConfig, BridgeRequest, BridgeRequestWithType } from "../../libs/types/pod-bridge.types";
+import { PodBridgeConfig, BridgeRequest, BridgeRequestWithType, CertifiedLog } from "../../libs/types/pod-bridge.types";
 export declare class PodBridgeTrackerClient {
     private readonly config;
-    private readonly sourceProvider;
-    private readonly destProvider;
-    private readonly sourceBridge;
-    private readonly destBridge;
+    private readonly bridgedProvider;
+    private readonly podProvider;
+    private readonly bridgedBridge;
+    private readonly podBridge;
     private readonly iface;
     constructor(config: PodBridgeConfig);
     /**
@@ -54,4 +54,36 @@ export declare class PodBridgeTrackerClient {
      * @returns Request hash
      */
     private computeRequestHash;
+    /**
+     * Get certified log for a deposit transaction from POD
+     * This is required to claim tokens on Sepolia from POD deposits
+     * @param txHash Transaction hash of the deposit on POD
+     * @returns Certified log with attestations and merkle proof
+     */
+    getDepositCertifiedLog(txHash: string): Promise<CertifiedLog>;
+    /**
+     * Compute receipt root hash
+     * @private
+     */
+    private computeReceiptRoot;
+    /**
+     * Aggregate signatures from attestations
+     * @private
+     */
+    private aggregateSignatures;
+    /**
+     * Hash a log entry
+     * @private
+     */
+    private hashLog;
+    /**
+     * Hash a leaf for merkle tree
+     * @private
+     */
+    private hashLeaf;
+    /**
+     * Generate merkle proof for a log at given index
+     * @private
+     */
+    private generateMerkleProof;
 }

package/dist/clients/tracker/client.js

@@ -8,11 +8,11 @@ class PodBridgeTrackerClient {
     constructor(config) {
         this.config = config;
         // Initialize providers
-        this.sourceProvider = new ethers_1.ethers.JsonRpcProvider(config.source.rpcUrl);
-        this.destProvider = new ethers_1.ethers.JsonRpcProvider(config.destination.rpcUrl);
+        this.bridgedProvider = new ethers_1.ethers.JsonRpcProvider(config.bridged.rpcUrl);
+        this.podProvider = new ethers_1.ethers.JsonRpcProvider(config.pod.rpcUrl);
         // Initialize contract instances
-        this.sourceBridge = new ethers_1.Contract(config.source.contractAddress, bridge_abi_1.POD_BRIDGE_ABI, this.sourceProvider);
-        this.destBridge = new ethers_1.Contract(config.destination.contractAddress, bridge_abi_1.POD_BRIDGE_ABI, this.destProvider);
+        this.bridgedBridge = new ethers_1.Contract(config.bridged.contractAddress, bridge_abi_1.POD_BRIDGE_ABI, this.bridgedProvider);
+        this.podBridge = new ethers_1.Contract(config.pod.contractAddress, bridge_abi_1.POD_BRIDGE_ABI, this.podProvider);
         // Interface for parsing logs
         this.iface = new ethers_1.Interface(bridge_abi_1.POD_BRIDGE_ABI);
     }
@@ -23,24 +23,23 @@ class PodBridgeTrackerClient {
      * @returns Array of bridge requests sent by this address
      */
     async getDepositsSentBy(address, fromBlock = 0) {
-        console.log(`Fetching deposits sent by ${address}...`);
         const deposits = [];
-        const currentBlock = await this.sourceProvider.getBlockNumber();
+        const currentBlock = await this.bridgedProvider.getBlockNumber();
         const BLOCK_BATCH_SIZE = 10000;
         for (let start = fromBlock; start <= currentBlock; start += BLOCK_BATCH_SIZE) {
             const end = Math.min(start + BLOCK_BATCH_SIZE - 1, currentBlock);
             // With improved events, we can filter by 'from' directly!
-            const depositFilter = this.sourceBridge.filters.Deposit(null, // id
+            const depositFilter = this.bridgedBridge.filters.Deposit(null, // id
             address, // from (indexed) - Filter by sender!
             null // to
             );
-            const depositNativeFilter = this.sourceBridge.filters.DepositNative(null, // id
+            const depositNativeFilter = this.bridgedBridge.filters.DepositNative(null, // id
             address, // from (indexed) - Filter by sender!
             null // to
             );
             const [depositLogs, depositNativeLogs] = await Promise.all([
-                this.sourceBridge.queryFilter(depositFilter, start, end),
-                this.sourceBridge.queryFilter(depositNativeFilter, start, end)
+                this.bridgedBridge.queryFilter(depositFilter, start, end),
+                this.bridgedBridge.queryFilter(depositNativeFilter, start, end)
             ]);
             // Process Deposit events
             for (const log of depositLogs) {
@@ -94,24 +93,23 @@ class PodBridgeTrackerClient {
      * @returns Array of bridge requests sent to this address
      */
     async getDepositsReceivedBy(address, fromBlock = 0) {
-        console.log(`Fetching deposits received by ${address}...`);
         const deposits = [];
-        const currentBlock = await this.sourceProvider.getBlockNumber();
+        const currentBlock = await this.bridgedProvider.getBlockNumber();
         const BLOCK_BATCH_SIZE = 10000;
         for (let start = fromBlock; start <= currentBlock; start += BLOCK_BATCH_SIZE) {
             const end = Math.min(start + BLOCK_BATCH_SIZE - 1, currentBlock);
             // With improved events, we can filter by 'to' directly!
-            const depositFilter = this.sourceBridge.filters.Deposit(null, // id
+            const depositFilter = this.bridgedBridge.filters.Deposit(null, // id
             null, // from
             address // to (indexed) - Filter by recipient!
             );
-            const depositNativeFilter = this.sourceBridge.filters.DepositNative(null, // id
+            const depositNativeFilter = this.bridgedBridge.filters.DepositNative(null, // id
             null, // from
             address // to (indexed) - Filter by recipient!
             );
             const [depositLogs, depositNativeLogs] = await Promise.all([
-                this.sourceBridge.queryFilter(depositFilter, start, end),
-                this.sourceBridge.queryFilter(depositNativeFilter, start, end)
+                this.bridgedBridge.queryFilter(depositFilter, start, end),
+                this.bridgedBridge.queryFilter(depositNativeFilter, start, end)
             ]);
             // Process Deposit events
             for (const log of depositLogs) {
@@ -165,7 +163,6 @@ class PodBridgeTrackerClient {
      * @returns Array of bridge requests with type indicator
      */
     async getAllDepositsFor(address, fromBlock = 0) {
-        console.log(`Fetching all deposits for ${address}...`);
         // Fetch both sent and received in parallel
         const [sent, received] = await Promise.all([
             this.getDepositsSentBy(address, fromBlock),
@@ -205,7 +202,7 @@ class PodBridgeTrackerClient {
      * @returns True if the deposit can be claimed
      */
     async canBeClaimed(deposit) {
-        const currentBlock = await this.sourceProvider.getBlockNumber();
+        const currentBlock = await this.bridgedProvider.getBlockNumber();
         const finalizedBlock = currentBlock - 15; // ~15 minutes on Sepolia
         return deposit.blockNumber <= finalizedBlock && !deposit.isClaimed;
     }
@@ -214,16 +211,16 @@ class PodBridgeTrackerClient {
      * @param deposits Array of deposits to check
      */
     async updateClaimStatus(deposits) {
-        if (deposits.length === 0)
+        if (deposits.length === 0) {
             return;
-        console.log(`Checking claim status for ${deposits.length} deposits...`);
+        }
         try {
             // Get claim events from destination chain
-            const claimFilter = this.destBridge.filters.Claim();
-            const claimNativeFilter = this.destBridge.filters.ClaimNative();
+            const claimFilter = this.podBridge.filters.Claim();
+            const claimNativeFilter = this.podBridge.filters.ClaimNative();
             const [claimLogs, claimNativeLogs] = await Promise.all([
-                this.destBridge.queryFilter(claimFilter),
-                this.destBridge.queryFilter(claimNativeFilter)
+                this.podBridge.queryFilter(claimFilter),
+                this.podBridge.queryFilter(claimNativeFilter)
             ]);
             // Create a map of claimed request IDs
             const claimedMap = new Map();
@@ -268,8 +265,7 @@ class PodBridgeTrackerClient {
             const tokens = deposits.map(d => d.token);
             const amounts = deposits.map(d => d.amount);
             const tos = deposits.map(d => d.to);
-            const results = await this.destBridge.areRequestsProcessed(ids, tokens, amounts, tos);
-            return results;
+            return await this.podBridge.areRequestsProcessed(ids, tokens, amounts, tos);
         }
         catch (error) {
             console.error('Batch check failed, falling back to individual checks:', error);
@@ -278,7 +274,7 @@ class PodBridgeTrackerClient {
             for (const deposit of deposits) {
                 try {
                     const hash = this.computeRequestHash(deposit.requestId, deposit.token, deposit.amount, deposit.to);
-                    const isProcessed = await this.destBridge.processedRequests(hash);
+                    const isProcessed = await this.podBridge.processedRequests(hash);
                     results.push(isProcessed);
                 }
                 catch (_a) {
@@ -299,5 +295,157 @@ class PodBridgeTrackerClient {
     computeRequestHash(id, token, amount, to) {
         return ethers_1.ethers.solidityPackedKeccak256(['uint256', 'address', 'uint256', 'address'], [id, token, amount, to]);
     }
+    /**
+     * Get certified log for a deposit transaction from POD
+     * This is required to claim tokens on Sepolia from POD deposits
+     * @param txHash Transaction hash of the deposit on POD
+     * @returns Certified log with attestations and merkle proof
+     */
+    async getDepositCertifiedLog(txHash) {
+        // Fetch the transaction receipt with POD metadata
+        const receipt = await this.podProvider.getTransactionReceipt(txHash);
+        if (!receipt) {
+            throw new Error(`Transaction receipt not found for hash: ${txHash}`);
+        }
+        if (!receipt.pod_metadata || !receipt.pod_metadata.attestations) {
+            throw new Error(`Transaction ${txHash} does not have POD metadata with attestations`);
+        }
+        if (receipt.logs.length === 0) {
+            throw new Error(`No logs found in transaction ${txHash}`);
+        }
+        // Find the Deposit or DepositNative event
+        const depositLog = receipt.logs.find(log => {
+            const topics = log.topics;
+            if (topics.length === 0)
+                return false;
+            const depositEventSig = ethers_1.ethers.id('Deposit(uint256,address,address,address,uint256,uint256,uint256)');
+            const depositNativeEventSig = ethers_1.ethers.id('DepositNative(uint256,address,address,uint256,uint256,uint256)');
+            return topics[0] === depositEventSig || topics[0] === depositNativeEventSig;
+        });
+        if (!depositLog) {
+            throw new Error(`No Deposit or DepositNative event found in transaction ${txHash}`);
+        }
+        // Compute receipt root (hash of receipt without pod_metadata)
+        const receiptRoot = this.computeReceiptRoot(receipt);
+        // Generate aggregate signature from attestations
+        const sortedAttestations = [...receipt.pod_metadata.attestations].sort((a, b) => a.timestamp - b.timestamp);
+        const aggregateSignature = this.aggregateSignatures(sortedAttestations);
+        const sortedTimestamps = sortedAttestations.map(att => BigInt(Math.floor(att.timestamp / 1000000))); // Convert microseconds to seconds
+        // Generate merkle proof for the log
+        const proof = this.generateMerkleProof(receipt.logs, parseInt(depositLog.logIndex));
+        // Compute leaf hash
+        const logHash = this.hashLog({
+            addr: depositLog.address,
+            topics: depositLog.topics,
+            data: depositLog.data
+        });
+        const leaf = this.hashLeaf(`log_hashes[${depositLog.logIndex}]`, logHash);
+        return {
+            log: {
+                addr: depositLog.address,
+                topics: depositLog.topics,
+                data: depositLog.data
+            },
+            logIndex: BigInt(depositLog.logIndex),
+            certificate: {
+                leaf,
+                certifiedReceipt: {
+                    receiptRoot,
+                    aggregateSignature,
+                    sortedAttestationTimestamps: sortedTimestamps
+                },
+                proof: {
+                    path: proof
+                }
+            }
+        };
+    }
+    /**
+     * Compute receipt root hash
+     * @private
+     */
+    computeReceiptRoot(receipt) {
+        // Create a simplified receipt object without pod_metadata for hashing
+        const logs = receipt.logs.map(log => ({
+            address: log.address,
+            topics: log.topics,
+            data: log.data
+        }));
+        // Receipt RLP encoding fields (simplified - matches POD's receipt structure)
+        const receiptData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint8', 'uint256', 'bytes32', 'uint256', 'tuple(address,bytes32[],bytes)[]'], [
+            parseInt(receipt.status),
+            BigInt(receipt.cumulativeGasUsed),
+            receipt.logsBloom,
+            BigInt(receipt.gasUsed),
+            logs.map(log => [log.address, log.topics, log.data])
+        ]);
+        return ethers_1.ethers.keccak256(receiptData);
+    }
+    /**
+     * Aggregate signatures from attestations
+     * @private
+     */
+    aggregateSignatures(attestations) {
+        // Concatenate all signatures (r, s, v format)
+        const signatures = attestations.map(att => {
+            const r = att.signature.r.startsWith('0x') ? att.signature.r.slice(2) : att.signature.r;
+            const s = att.signature.s.startsWith('0x') ? att.signature.s.slice(2) : att.signature.s;
+            const v = att.signature.v.startsWith('0x') ? att.signature.v.slice(2) : att.signature.v;
+            return r + s + v.padStart(2, '0');
+        });
+        return '0x' + signatures.join('');
+    }
+    /**
+     * Hash a log entry
+     * @private
+     */
+    hashLog(log) {
+        return ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['address', 'bytes32[]', 'bytes'], [log.addr, log.topics, log.data]));
+    }
+    /**
+     * Hash a leaf for merkle tree
+     * @private
+     */
+    hashLeaf(key, value) {
+        return ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['bytes', 'bytes32'], [ethers_1.ethers.toUtf8Bytes(key), value]));
+    }
+    /**
+     * Generate merkle proof for a log at given index
+     * @private
+     */
+    generateMerkleProof(logs, logIndex) {
+        // Hash all logs
+        const logHashes = logs.map((log, idx) => this.hashLeaf(`log_hashes[${idx}]`, this.hashLog({
+            addr: log.address,
+            topics: log.topics,
+            data: log.data
+        })));
+        // Build merkle tree and generate proof
+        const proof = [];
+        let currentIndex = logIndex;
+        let currentLevel = [...logHashes];
+        while (currentLevel.length > 1) {
+            const nextLevel = [];
+            for (let i = 0; i < currentLevel.length; i += 2) {
+                if (i + 1 < currentLevel.length) {
+                    // Pair exists
+                    const left = currentLevel[i];
+                    const right = currentLevel[i + 1];
+                    // Add sibling to proof if current index is in this pair
+                    if (i === currentIndex || i + 1 === currentIndex) {
+                        proof.push(i === currentIndex ? right : left);
+                    }
+                    nextLevel.push(ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['bytes32', 'bytes32'], [left, right])));
+                }
+                else {
+                    // Odd node, promote to next level
+                    nextLevel.push(currentLevel[i]);
+                }
+            }
+            currentIndex = Math.floor(currentIndex / 2);
+            currentLevel = nextLevel;
+        }
+        return proof;
+    }
 }
 exports.PodBridgeTrackerClient = PodBridgeTrackerClient;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { PodBridgeActionClient } from './clients/action/client';
+export { PodToBridgedActionClient } from './clients/action/pod-to-bridged-client';
+export { BridgedToPodActionClient } from './clients/action/bridged-to-pod-client';
 export { PodBridgeTrackerClient } from './clients/tracker/client';
 export { POD_BRIDGE_ABI } from './libs/abi/bridge.abi';
-export { PodBridgeConfig, BridgeRequest, BridgeRequestWithType, DepositType, UnsignedTransaction, CertifiedLog, } from './libs/types/pod-bridge.types';
+export { PodBridgeConfig, BridgeRequest, BridgeRequestWithType, DepositType, UnsignedTransaction, CertifiedLog, PodAttestation, PodMetadata, PodTransactionReceipt, } from './libs/types/pod-bridge.types';

package/dist/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepositType = exports.POD_BRIDGE_ABI = exports.PodBridgeTrackerClient = exports.PodBridgeActionClient = void 0;
-var client_1 = require("./clients/action/client");
-Object.defineProperty(exports, "PodBridgeActionClient", { enumerable: true, get: function () { return client_1.PodBridgeActionClient; } });
-var client_2 = require("./clients/tracker/client");
-Object.defineProperty(exports, "PodBridgeTrackerClient", { enumerable: true, get: function () { return client_2.PodBridgeTrackerClient; } });
+exports.DepositType = exports.POD_BRIDGE_ABI = exports.PodBridgeTrackerClient = exports.BridgedToPodActionClient = exports.PodToBridgedActionClient = void 0;
+var pod_to_bridged_client_1 = require("./clients/action/pod-to-bridged-client");
+Object.defineProperty(exports, "PodToBridgedActionClient", { enumerable: true, get: function () { return pod_to_bridged_client_1.PodToBridgedActionClient; } });
+var bridged_to_pod_client_1 = require("./clients/action/bridged-to-pod-client");
+Object.defineProperty(exports, "BridgedToPodActionClient", { enumerable: true, get: function () { return bridged_to_pod_client_1.BridgedToPodActionClient; } });
+var client_1 = require("./clients/tracker/client");
+Object.defineProperty(exports, "PodBridgeTrackerClient", { enumerable: true, get: function () { return client_1.PodBridgeTrackerClient; } });
 var bridge_abi_1 = require("./libs/abi/bridge.abi");
 Object.defineProperty(exports, "POD_BRIDGE_ABI", { enumerable: true, get: function () { return bridge_abi_1.POD_BRIDGE_ABI; } });
 var pod_bridge_types_1 = require("./libs/types/pod-bridge.types");

package/dist/libs/types/pod-bridge.types.d.ts

@@ -2,9 +2,22 @@ export interface PodBridgeChainConfig {
     rpcUrl: string;
     contractAddress: string;
 }
+/**
+ * Configuration for the bridge
+ * * bridged: Configuration for the bridged chain. BridgeDepositWithdraw contract address
+ * * pod: Configuration for the POD chain. BridgeMintBurn contract address
+ */
 export interface PodBridgeConfig {
-    source: PodBridgeChainConfig;
-    destination: PodBridgeChainConfig;
+    bridged: PodBridgeChainConfig;
+    pod: PodBridgeChainConfig;
+}
+export interface PodBridgeActionsClientConfig {
+    bridged: {
+        contractAddress: string;
+    };
+    pod: {
+        contractAddress: string;
+    };
 }
 export interface BridgeRequest {
     requestId: string;
@@ -41,9 +54,56 @@ export interface CertifiedLog {
         topics: string[];
         data: string;
     };
-    sigs: Array<{
+    logIndex: bigint | string;
+    certificate: {
+        leaf: string;
+        certifiedReceipt: {
+            receiptRoot: string;
+            aggregateSignature: string;
+            sortedAttestationTimestamps: bigint[] | string[];
+        };
+        proof: {
+            path: string[];
+        };
+    };
+}
+export interface PodAttestation {
+    public_key: string;
+    signature: {
         r: string;
         s: string;
-        v: number;
+        v: string;
+        yParity: string;
+    };
+    timestamp: number;
+}
+export interface PodMetadata {
+    attestations: PodAttestation[];
+}
+export interface PodTransactionReceipt {
+    blockHash: string;
+    blockNumber: string;
+    contractAddress: string | null;
+    cumulativeGasUsed: string;
+    effectiveGasPrice: string;
+    from: string;
+    gasUsed: string;
+    logs: Array<{
+        address: string;
+        topics: string[];
+        data: string;
+        blockNumber: string;
+        transactionHash: string;
+        transactionIndex: string;
+        blockHash: string;
+        logIndex: string;
+        removed: boolean;
     }>;
+    logsBloom: string;
+    pod_metadata: PodMetadata;
+    status: string;
+    to: string;
+    transactionHash: string;
+    transactionIndex: string;
+    type: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapforce/pod-bridge-sdk",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "SDK for interacting with Bridges between pod and other chains",
   "keywords": [
     "pod",