@tapforce/pod-bridge-sdk 1.1.17 → 1.2.1

package/dist/libs/abi/bridge.abi.js

@@ -1,49 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOURCE_CHAIN_BRIDGE_ABI = exports.POD_BRIDGE_ABI = void 0;
+exports.POD_BRIDGE_ABI = exports.SOURCE_CHAIN_BRIDGE_ABI = exports.BRIDGE_ABI = void 0;
 /**
- * ABI for BridgeMintBurn contract on POD Chain
- * - Deposits burn tokens
- * - Claims use block number verification via precompiles
+ * ABI for Bridge contract on Source Chain (ETH/Sepolia)
+ * New architecture:
+ * - ETH -> Pod: deposit on ETH, auto-claim on Pod (no claim needed)
+ * - Pod -> ETH: deposit on Pod, claim on ETH with aggregated validator signatures
+ * - Only ERC20 tokens supported (no native ETH - must wrap to WETH)
  */
-exports.POD_BRIDGE_ABI = [
+exports.BRIDGE_ABI = [
     // Events
-    "event Deposit(uint256 indexed id, address indexed from, address indexed to, address token, uint256 amount, uint256 timestamp, uint256 blockNumber)",
-    "event DepositNative(uint256 indexed id, address indexed from, address indexed to, uint256 amount, uint256 timestamp, uint256 blockNumber)",
-    "event Claim(uint256 indexed id, address indexed claimer, address indexed to, address mirrorToken, address token, uint256 amount, uint256 timestamp)",
-    "event ClaimNative(uint256 indexed id, address indexed claimer, address indexed to, uint256 amount, uint256 timestamp)",
-    "event BurnNative(address indexed from, uint256 amount)",
-    // Deposit functions
-    "function deposit(address token, uint256 amount, address to) returns (uint256)",
-    "function depositNative(address to) payable returns (uint256)",
-    // Claim functions (use block number verification)
-    "function claim(uint256 id, address token, uint256 blockNumber)",
-    "function claimNative(uint256 id, uint256 blockNumber)",
+    "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)",
+    // Deposit function (ERC20 only)
+    "function deposit(address token, uint256 amount, address to) returns (bytes32)",
+    // Claim function with aggregated validator signatures
+    "function claim(address token, uint256 amount, address to, uint64 committeeEpoch, bytes aggregatedSignatures, bytes proof)",
     // View functions
     "function processedRequests(bytes32) view returns (bool)",
-    "function bridgeContract() view returns (address)",
-    "function SOURCE_CHAIN_ID() view returns (uint96)",
-    "function areRequestsProcessed(uint256[] ids, address[] tokens, uint256[] amounts, address[] tos) view returns (bool[])",
-];
-/**
- * ABI for BridgeDepositWithdraw contract on Source Chain (e.g., Sepolia)
- * - Deposits lock tokens
- * - Claims use POD certificates with attestations and merkle proofs
- */
-exports.SOURCE_CHAIN_BRIDGE_ABI = [
-    // Events
-    "event Deposit(uint256 indexed id, address indexed from, address indexed to, address token, uint256 amount, uint256 timestamp, uint256 blockNumber)",
-    "event DepositNative(uint256 indexed id, address indexed from, address indexed to, uint256 amount, uint256 timestamp, uint256 blockNumber)",
-    "event Claim(uint256 indexed id, address indexed claimer, address indexed to, address mirrorToken, address token, uint256 amount, uint256 timestamp)",
-    "event ClaimNative(uint256 indexed id, address indexed claimer, address indexed to, uint256 amount, uint256 timestamp)",
-    // Deposit functions
-    "function deposit(address token, uint256 amount, address to) returns (uint256)",
-    "function depositNative(address to) payable returns (uint256)",
-    // Claim functions (use PodECDSA.CertifiedLog with certificates)
-    "function claim(tuple(tuple(address addr, bytes32[] topics, bytes data) log, uint256 logIndex, tuple(tuple(bytes32 receiptRoot, bytes aggregateSignature, uint256[] sortedAttestationTimestamps) certifiedReceipt, bytes32 leaf, tuple(bytes32[] path) proof) certificate) certifiedLog)",
-    "function claimNative(tuple(tuple(address addr, bytes32[] topics, bytes data) log, uint256 logIndex, tuple(tuple(bytes32 receiptRoot, bytes aggregateSignature, uint256[] sortedAttestationTimestamps) certifiedReceipt, bytes32 leaf, tuple(bytes32[] path) proof) certificate) certifiedLog)",
-    // View functions
-    "function processedRequests(bytes32) view returns (bool)",
-    "function bridgeContract() view returns (address)",
-    "function areRequestsProcessed(uint256[] ids, address[] tokens, uint256[] amounts, address[] tos) view returns (bool[])",
+    "function BRIDGE_CONTRACT() view returns (address)",
+    "function DOMAIN_SEPARATOR() view returns (bytes32)",
+    "function tokenData(address) view returns (uint256 minAmount, uint256 depositLimit, uint256 claimLimit, tuple(uint256 consumed, uint256 lastUpdated) depositUsage, tuple(uint256 consumed, uint256 lastUpdated) claimUsage, address mirrorToken)",
+    "function whitelistedTokens(uint256) view returns (address)",
+    "function depositIndex() view returns (uint256)",
 ];
+// Legacy alias for backwards compatibility
+exports.SOURCE_CHAIN_BRIDGE_ABI = exports.BRIDGE_ABI;
+exports.POD_BRIDGE_ABI = exports.BRIDGE_ABI;

package/dist/libs/helpers/convert-certified-log.helper.d.ts

@@ -1,23 +1,11 @@
-import { CertifiedLog } from "../types/pod-bridge.types";
 /**
- * Convert FFI CertifiedLog to the TypeScript CertifiedLog format
+ * @deprecated This helper is no longer needed in the new bridge architecture.
+ *
+ * The new bridge uses aggregated validator signatures instead of certified logs.
+ * See signature-recovery.helper.ts for the new signature recovery utilities.
+ *
+ * New architecture:
+ * - ETH -> Pod: Auto-claim on Pod (no claim transaction needed)
+ * - Pod -> ETH: Claim with aggregated 65-byte ECDSA signatures
  */
-export declare const convertFFICertifiedLog: (ffi: CertifiedLog) => {
-    log: {
-        addr: string;
-        topics: string[];
-        data: string;
-    };
-    logIndex: bigint;
-    certificate: {
-        certifiedReceipt: {
-            receiptRoot: string;
-            aggregateSignature: string;
-            sortedAttestationTimestamps: bigint[];
-        };
-        leaf: string;
-        proof: {
-            path: string[];
-        };
-    };
-};
+export declare const convertFFICertifiedLog: (_ffi: unknown) => never;

package/dist/libs/helpers/convert-certified-log.helper.js

@@ -1,28 +1,19 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFFICertifiedLog = void 0;
 /**
- * Convert FFI CertifiedLog to the TypeScript CertifiedLog format
+ * @deprecated This helper is no longer needed in the new bridge architecture.
+ *
+ * The new bridge uses aggregated validator signatures instead of certified logs.
+ * See signature-recovery.helper.ts for the new signature recovery utilities.
+ *
+ * New architecture:
+ * - ETH -> Pod: Auto-claim on Pod (no claim transaction needed)
+ * - Pod -> ETH: Claim with aggregated 65-byte ECDSA signatures
  */
-const convertFFICertifiedLog = (ffi) => {
-    return {
-        log: {
-            addr: ffi.log.addr,
-            topics: ffi.log.topics,
-            data: ffi.log.data,
-        },
-        logIndex: BigInt(ffi.log_index),
-        certificate: {
-            certifiedReceipt: {
-                receiptRoot: ffi.certificate.certified_receipt.receipt_root,
-                aggregateSignature: ffi.certificate.certified_receipt.aggregate_signature,
-                sortedAttestationTimestamps: ffi.certificate.certified_receipt.sorted_attestation_timestamps.map(t => BigInt(t)),
-            },
-            leaf: ffi.certificate.leaf,
-            proof: {
-                path: ffi.certificate.proof.path,
-            },
-        },
-    };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFFICertifiedLog = void 0;
+// Kept for backwards compatibility, but will be removed in future versions
+const convertFFICertifiedLog = (_ffi) => {
+    console.warn('[DEPRECATED] convertFFICertifiedLog is deprecated. Use signature-recovery.helper.ts instead.');
+    throw new Error('CertifiedLog format is no longer supported. Use ClaimProofData with aggregated signatures.');
 };
 exports.convertFFICertifiedLog = convertFFICertifiedLog;

package/dist/libs/helpers/signature-recovery.helper.d.ts

@@ -0,0 +1,91 @@
+import { PodTransactionReceipt } from '../pod-sdk/src/types/responses';
+/**
+ * Derive Ethereum address from a public key.
+ *
+ * @param publicKey The public key (uncompressed 65 bytes with 04 prefix, or 64 bytes x||y)
+ * @returns The Ethereum address
+ */
+export declare function addressFromPublicKey(publicKey: string): string;
+/**
+ * Recover a 65-byte ECDSA signature (r,s,v) from a 64-byte compact signature.
+ *
+ * Exactly matches the Rust implementation:
+ * ```rust
+ * pub fn recover_65b_signature(
+ *     sig: &Signature,
+ *     msg_hash: [u8; 32],
+ *     pubkey: &PublicKey,
+ * ) -> anyhow::Result<[u8; 65]> {
+ *     let secp = Secp256k1::new();
+ *     let msg = Message::from_digest(msg_hash);
+ *     let sig_bytes = sig.serialize_compact();
+ *
+ *     for recovery_id in [RecoveryId::Zero, RecoveryId::One] {
+ *         let recoverable_sig = RecoverableSignature::from_compact(&sig_bytes, recovery_id)?;
+ *         match secp.recover_ecdsa(msg, &recoverable_sig) {
+ *             Ok(recovered_key) => {
+ *                 if recovered_key == *pubkey {
+ *                     return Ok(recoverable_sig.to_alloy().as_bytes());
+ *                 }
+ *             }
+ *             Err(e) => { ... }
+ *         }
+ *     }
+ *     Err(anyhow!("Could not find valid recovery ID for signature"))
+ * }
+ * ```
+ *
+ * @param r The r component of the signature (32 bytes hex)
+ * @param s The s component of the signature (32 bytes hex)
+ * @param msgHash The 32-byte message hash that was signed
+ * @param publicKey The expected signer's public key
+ * @returns The 65-byte signature (r || s || v) or null if recovery fails
+ */
+export declare function recoverSignature65B(r: string, s: string, msgHash: string, publicKey: string): string | null;
+/**
+ * Recover multiple 65-byte signatures from concatenated 64-byte signatures.
+ *
+ * @param aggregatedSig64 Concatenated 64-byte signatures (r || s for each)
+ * @param msgHash The message hash that was signed
+ * @param publicKeys Array of expected signer public keys in order
+ * @returns Concatenated 65-byte signatures or null if any recovery fails
+ */
+export declare function recoverAggregatedSignatures65B(aggregatedSig64: string | Uint8Array, msgHash: string, publicKeys: string[]): string | null;
+/**
+ * Compute the transaction hash for a bridge deposit that needs to be signed.
+ * This matches the depositTxHash function in the Bridge.sol contract.
+ *
+ * @param domainSeparator The domain separator from the bridge contract
+ * @param bridgeContract The address of the bridge contract on the other chain
+ * @param token The token address
+ * @param amount The amount
+ * @param to The recipient address
+ * @param proof The proof (deposit TX hash)
+ * @returns The transaction hash to be signed
+ */
+export declare function computeDepositTxHash(domainSeparator: string, bridgeContract: string, token: string, amount: bigint | string, to: string, proof: string): string;
+/**
+ * Extract aggregated 65-byte signatures from Pod transaction receipt attestations.
+ *
+ * Exactly matches the Rust implementation - recovers the v (parity bit) by trying
+ * both recovery IDs and checking which one recovers to the correct public key.
+ *
+ * @param receipt The Pod transaction receipt
+ * @param msgHash The message hash that validators signed (transaction hash)
+ * @returns Concatenated 65-byte signatures (r || s || v for each attestation)
+ */
+export declare function extractAggregatedSignatures(receipt: PodTransactionReceipt, msgHash?: string): string;
+/**
+ * Extract attestation data from Pod receipt for debugging/verification.
+ * Uses recoverSignature65B to properly recover v value.
+ *
+ * @param receipt The Pod transaction receipt
+ * @param msgHash The message hash that validators signed
+ * @returns Array of attestation info with public keys and recovered signatures
+ */
+export declare function extractAttestationInfo(receipt: PodTransactionReceipt, msgHash?: string): Array<{
+    publicKey: string;
+    address: string;
+    signature: string;
+    timestamp: number;
+}>;

package/dist/libs/helpers/signature-recovery.helper.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressFromPublicKey = addressFromPublicKey;
+exports.recoverSignature65B = recoverSignature65B;
+exports.recoverAggregatedSignatures65B = recoverAggregatedSignatures65B;
+exports.computeDepositTxHash = computeDepositTxHash;
+exports.extractAggregatedSignatures = extractAggregatedSignatures;
+exports.extractAttestationInfo = extractAttestationInfo;
+const ethers_1 = require("ethers");
+/**
+ * Derive Ethereum address from a public key.
+ *
+ * @param publicKey The public key (uncompressed 65 bytes with 04 prefix, or 64 bytes x||y)
+ * @returns The Ethereum address
+ */
+function addressFromPublicKey(publicKey) {
+    const pubKeyHex = publicKey.replace('0x', '');
+    // Handle different public key formats
+    let xyBytes;
+    if (pubKeyHex.length === 130 && pubKeyHex.startsWith('04')) {
+        // Uncompressed: 04 + x (32 bytes) + y (32 bytes)
+        xyBytes = pubKeyHex.slice(2);
+    }
+    else if (pubKeyHex.length === 128) {
+        // Already x || y without prefix
+        xyBytes = pubKeyHex;
+    }
+    else {
+        throw new Error(`Invalid public key length: ${pubKeyHex.length}. Expected 128 or 130 hex chars.`);
+    }
+    // Address = keccak256(x || y)[12:] = last 20 bytes
+    const hash = (0, ethers_1.keccak256)('0x' + xyBytes);
+    return '0x' + hash.slice(-40);
+}
+/**
+ * Recover a 65-byte ECDSA signature (r,s,v) from a 64-byte compact signature.
+ *
+ * Exactly matches the Rust implementation:
+ * ```rust
+ * pub fn recover_65b_signature(
+ *     sig: &Signature,
+ *     msg_hash: [u8; 32],
+ *     pubkey: &PublicKey,
+ * ) -> anyhow::Result<[u8; 65]> {
+ *     let secp = Secp256k1::new();
+ *     let msg = Message::from_digest(msg_hash);
+ *     let sig_bytes = sig.serialize_compact();
+ *
+ *     for recovery_id in [RecoveryId::Zero, RecoveryId::One] {
+ *         let recoverable_sig = RecoverableSignature::from_compact(&sig_bytes, recovery_id)?;
+ *         match secp.recover_ecdsa(msg, &recoverable_sig) {
+ *             Ok(recovered_key) => {
+ *                 if recovered_key == *pubkey {
+ *                     return Ok(recoverable_sig.to_alloy().as_bytes());
+ *                 }
+ *             }
+ *             Err(e) => { ... }
+ *         }
+ *     }
+ *     Err(anyhow!("Could not find valid recovery ID for signature"))
+ * }
+ * ```
+ *
+ * @param r The r component of the signature (32 bytes hex)
+ * @param s The s component of the signature (32 bytes hex)
+ * @param msgHash The 32-byte message hash that was signed
+ * @param publicKey The expected signer's public key
+ * @returns The 65-byte signature (r || s || v) or null if recovery fails
+ */
+function recoverSignature65B(r, s, msgHash, publicKey) {
+    // Normalize r and s
+    const rHex = r.replace('0x', '').padStart(64, '0');
+    const sHex = s.replace('0x', '').padStart(64, '0');
+    // Derive expected address from public key
+    let expectedAddress;
+    try {
+        expectedAddress = addressFromPublicKey(publicKey);
+    }
+    catch (e) {
+        console.error('Failed to derive address from public key:', e);
+        return null;
+    }
+    // Try both recovery IDs (27 and 28 in Ethereum, corresponding to RecoveryId::Zero and RecoveryId::One)
+    for (const v of [27, 28]) {
+        try {
+            const signature = { r: '0x' + rHex, s: '0x' + sHex, v };
+            const recoveredAddress = (0, ethers_1.recoverAddress)(msgHash, signature);
+            if (recoveredAddress.toLowerCase() === expectedAddress.toLowerCase()) {
+                // Found the correct v value - matches Rust: "if recovered_key == *pubkey"
+                const vHex = v.toString(16).padStart(2, '0');
+                return '0x' + rHex + sHex + vHex;
+            }
+        }
+        catch (e) {
+            // Recovery failed with this v, try the other
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Recover multiple 65-byte signatures from concatenated 64-byte signatures.
+ *
+ * @param aggregatedSig64 Concatenated 64-byte signatures (r || s for each)
+ * @param msgHash The message hash that was signed
+ * @param publicKeys Array of expected signer public keys in order
+ * @returns Concatenated 65-byte signatures or null if any recovery fails
+ */
+function recoverAggregatedSignatures65B(aggregatedSig64, msgHash, publicKeys) {
+    const sigBytes = typeof aggregatedSig64 === 'string'
+        ? Uint8Array.from(Buffer.from(aggregatedSig64.replace('0x', ''), 'hex'))
+        : aggregatedSig64;
+    const sigCount = sigBytes.length / 64;
+    if (sigCount !== publicKeys.length) {
+        throw new Error(`Signature count (${sigCount}) doesn't match expected public keys count (${publicKeys.length})`);
+    }
+    const recovered65BSigs = [];
+    for (let i = 0; i < sigCount; i++) {
+        const offset = i * 64;
+        const r = '0x' + Buffer.from(sigBytes.slice(offset, offset + 32)).toString('hex');
+        const s = '0x' + Buffer.from(sigBytes.slice(offset + 32, offset + 64)).toString('hex');
+        const sig65 = recoverSignature65B(r, s, msgHash, publicKeys[i]);
+        if (!sig65) {
+            console.error(`Failed to recover signature ${i} for public key ${publicKeys[i]}`);
+            return null;
+        }
+        recovered65BSigs.push(sig65.replace('0x', ''));
+    }
+    return '0x' + recovered65BSigs.join('');
+}
+/**
+ * Compute the transaction hash for a bridge deposit that needs to be signed.
+ * This matches the depositTxHash function in the Bridge.sol contract.
+ *
+ * @param domainSeparator The domain separator from the bridge contract
+ * @param bridgeContract The address of the bridge contract on the other chain
+ * @param token The token address
+ * @param amount The amount
+ * @param to The recipient address
+ * @param proof The proof (deposit TX hash)
+ * @returns The transaction hash to be signed
+ */
+function computeDepositTxHash(domainSeparator, bridgeContract, token, amount, to, proof) {
+    const { AbiCoder, solidityPackedKeccak256 } = require('ethers');
+    const abiCoder = new AbiCoder();
+    // DEPOSIT_SELECTOR = keccak256("deposit(address,uint256,address)")[:4]
+    const DEPOSIT_SELECTOR = '0x47e7ef24';
+    // Compute dataHash = keccak256(selector || token || amount || to)
+    const dataHash = solidityPackedKeccak256(['bytes4', 'address', 'uint256', 'address'], [DEPOSIT_SELECTOR, token, amount, to]);
+    // Compute final hash = keccak256(domainSeparator || bridgeContract || dataHash || proof)
+    const txHash = (0, ethers_1.keccak256)(abiCoder.encode(['bytes32', 'address', 'bytes32', 'bytes'], [domainSeparator, bridgeContract, dataHash, proof]));
+    return txHash;
+}
+/**
+ * Extract aggregated 65-byte signatures from Pod transaction receipt attestations.
+ *
+ * Exactly matches the Rust implementation - recovers the v (parity bit) by trying
+ * both recovery IDs and checking which one recovers to the correct public key.
+ *
+ * @param receipt The Pod transaction receipt
+ * @param msgHash The message hash that validators signed (transaction hash)
+ * @returns Concatenated 65-byte signatures (r || s || v for each attestation)
+ */
+function extractAggregatedSignatures(receipt, msgHash) {
+    const attestations = receipt.pod_metadata?.attestations;
+    if (!attestations || attestations.length === 0) {
+        throw new Error('No attestations found in receipt');
+    }
+    // Use provided msgHash or fall back to transaction hash
+    const hashToSign = msgHash || receipt.transactionHash;
+    const signatures = [];
+    for (const attestation of attestations) {
+        const { r, s } = attestation.signature;
+        const publicKey = attestation.public_key;
+        // Use recoverSignature65B to find correct v value - exactly like Rust code
+        const sig65 = recoverSignature65B(r, s, hashToSign, publicKey);
+        if (!sig65) {
+            throw new Error(`Failed to recover signature for public key ${publicKey}`);
+        }
+        signatures.push(sig65.replace('0x', ''));
+    }
+    return '0x' + signatures.join('');
+}
+/**
+ * Extract attestation data from Pod receipt for debugging/verification.
+ * Uses recoverSignature65B to properly recover v value.
+ *
+ * @param receipt The Pod transaction receipt
+ * @param msgHash The message hash that validators signed
+ * @returns Array of attestation info with public keys and recovered signatures
+ */
+function extractAttestationInfo(receipt, msgHash) {
+    const attestations = receipt.pod_metadata?.attestations;
+    if (!attestations || attestations.length === 0) {
+        return [];
+    }
+    const hashToSign = msgHash || receipt.transactionHash;
+    return attestations.map(att => {
+        const { r, s } = att.signature;
+        const publicKey = att.public_key;
+        // Recover signature with correct v value
+        const sig65 = recoverSignature65B(r, s, hashToSign, publicKey);
+        // Derive address from public key
+        let address = '';
+        try {
+            address = addressFromPublicKey(publicKey);
+        }
+        catch (e) {
+            // Ignore
+        }
+        return {
+            publicKey,
+            address,
+            signature: sig65 || 'recovery_failed',
+            timestamp: att.timestamp
+        };
+    });
+}

package/dist/libs/pod-sdk/src/provider/provider-builder.js

@@ -7,11 +7,10 @@ class PodProvider extends ethers_1.ethers.JsonRpcProvider {
         return await this.send('pod_getCommittee', {});
     }
     async getListReceipts(params) {
-        var _a;
         return await this.send('pod_listReceipts', [
-            (_a = params === null || params === void 0 ? void 0 : params.address) !== null && _a !== void 0 ? _a : null,
+            params?.address ?? null,
             params.since,
-            params === null || params === void 0 ? void 0 : params.pagination
+            params?.pagination
         ]);
     }
     async getMetrics() {

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

@@ -1,5 +1,6 @@
+import { Provider } from 'ethers';
 export interface PodBridgeChainConfig {
-    rpcUrl: string;
+    provider: Provider;
     contractAddress: string;
     deploymentBlock?: number;
 }
@@ -63,22 +64,37 @@ export interface UnsignedTransaction {
     chainId?: number;
     gasLimit?: bigint;
 }
-export interface CertifiedLog {
-    log: {
-        addr: string;
-        topics: string[];
-        data: string;
-    };
-    log_index: bigint | string;
-    certificate: {
-        leaf: string;
-        certified_receipt: {
-            receipt_root: string;
-            aggregate_signature: string;
-            sorted_attestation_timestamps: bigint[] | string[];
-        };
-        proof: {
-            path: string[];
-        };
-    };
+/**
+ * Claim proof data for claiming tokens on source chain (Pod -> ETH direction)
+ *
+ * Flow:
+ * 1. User deposits on Pod: pod_bridge.deposit(pod_token, amount, recipient)
+ * 2. User waits for TX receipt
+ * 3. User claims on ETH: eth_bridge.claim(eth_token, amount, recipient, epoch, signatures, txHash)
+ *
+ * Important:
+ * - Token addresses differ between Pod and ETH (deposit AAAA on Pod, claim BBBB on ETH)
+ * - Signatures must be 65-byte format (r,s,v) - use recoverSignature65B helper
+ * - Proof is the deposit transaction hash from Pod
+ */
+export interface ClaimProofData {
+    /** Token address on ETH to claim (different from Pod token address) */
+    ethTokenAddress: string;
+    /** Amount of tokens deposited/to claim (same as deposit amount) */
+    amount: string | bigint;
+    /** Recipient address (same as deposit recipient) */
+    to: string;
+    /** Committee epoch - hardcoded to 0 for now */
+    committeeEpoch: number;
+    /**
+     * Concatenated 65-byte ECDSA signatures (r,s,v) from validators.
+     * Pod uses 64-byte signatures, so use recoverSignature65B/recoverAggregatedSignatures65B
+     * to convert to 65-byte format required by the contract.
+     */
+    aggregatedSignatures: string;
+    /**
+     * The deposit transaction hash from Pod.
+     * This is used as proof that the deposit occurred.
+     */
+    depositTxHash: string;
 }

package/package.json

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