@tapforce/pod-bridge-sdk 1.0.1 → 1.0.3

package/README.md

@@ -46,11 +46,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
   }
@@ -98,32 +98,24 @@ const unsignedTx = actionClient.depositNative({
 
 #### Claim Tokens (with Certificate) - Sepolia from POD
 
-For claiming on Sepolia from POD deposits, use certificate-based claims:
+For claiming on Sepolia from POD deposits, use certificate-based claims. First, get the certified log from the POD deposit transaction:
 
 ```typescript
-// Obtain certified log from POD certificate system
-const certifiedLog = {
-  log: {
-    addr: '0x...',
-    topics: ['0x...'],
-    data: '0x...'
-  },
-  sigs: [
-    { r: '0x...', s: '0x...', v: 27 }
-  ]
-};
+// 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
 const unsignedTx = actionClient.claimWithCertificate({
   certifiedLog,
-  contractAddress: config.destination.contractAddress,
+  contractAddress: config.bridged.contractAddress, // Sepolia bridge contract
   from: '0x...' // Optional: claimer address
 });
 
 // For native tokens
 const unsignedNativeTx = actionClient.claimNativeWithCertificate({
   certifiedLog,
-  contractAddress: config.destination.contractAddress,
+  contractAddress: config.bridged.contractAddress,
   from: '0x...'
 });
 ```
@@ -291,6 +283,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 +330,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,7 +361,7 @@ The SDK supports two bridge implementations:
 
 ## Examples
 
-### Complete Deposit and Claim Flow
+### Complete Deposit and Claim Flow (Sepolia → POD)
 
 ```typescript
 import { ethers } from 'ethers';
@@ -366,57 +369,111 @@ import { PodBridgeActionClient, PodBridgeTrackerClient } from '@tapforce/pod-bri
 
 // Setup
 const config = {
-  source: {
+  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 sepoliaProvider = new ethers.JsonRpcProvider(config.bridged.rpcUrl);
+const sepoliaSigner = new ethers.Wallet('PRIVATE_KEY', sepoliaProvider);
 
-// Step 1: Deposit tokens
+// 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(),
+  contractAddress: config.bridged.contractAddress
 });
 
-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
+    contractAddress: config.pod.contractAddress
   });
   
-  // 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(config.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 { PodBridgeActionClient, PodBridgeTrackerClient } from '@tapforce/pod-bridge-sdk';
+
+// Setup
+const config = {
+  bridged: {
+    rpcUrl: 'https://sepolia.infura.io/v3/YOUR_KEY',
+    contractAddress: '0xSepoliaBridgeContract'
+  },
+  pod: {
+    rpcUrl: 'https://rpc.v1.dev.pod.network',
+    contractAddress: '0xPodBridgeContract'
+  }
+};
+
+const actionClient = new PodBridgeActionClient();
+const trackerClient = new PodBridgeTrackerClient(config);
+const podProvider = new ethers.JsonRpcProvider(config.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(),
+  contractAddress: config.pod.contractAddress
+});
+
+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,
+  contractAddress: config.bridged.contractAddress
+});
+
+const sepoliaProvider = new ethers.JsonRpcProvider(config.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

@@ -6,7 +6,7 @@ export declare class PodBridgeActionClient {
      * 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,21 +14,21 @@ export declare class PodBridgeActionClient {
     depositToken(args: {
         token: string;
         amount: string | bigint;
-        recipient: string;
+        destinationWalletAddress: string;
         contractAddress: 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;
+        destinationWalletAddress: string;
         contractAddress: string;
         from?: string;
     }): UnsignedTransaction;

package/dist/clients/action/client.js

@@ -11,7 +11,7 @@ class PodBridgeActionClient {
      * 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,7 +20,7 @@ class PodBridgeActionClient {
         const data = this.iface.encodeFunctionData('deposit', [
             args.token,
             args.amount,
-            args.recipient
+            args.destinationWalletAddress
         ]);
         return {
             to: args.contractAddress,
@@ -32,13 +32,13 @@ 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,
             data,

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,4 @@
 export { PodBridgeActionClient } from './clients/action/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/libs/types/pod-bridge.types.d.ts

@@ -2,9 +2,14 @@ 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 BridgeRequest {
     requestId: string;
@@ -41,9 +46,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.0.3",
   "description": "SDK for interacting with Bridges between pod and other chains",
   "keywords": [
     "pod",