@tapforce/pod-bridge-sdk 1.2.4 → 2.0.1

package/dist/libs/helpers/bridge-claim-proof.helper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBridgeClaimProof = getBridgeClaimProof;
+/**
+ * Convert a number[] byte array to a 0x-prefixed hex string.
+ */
+function bytesToHex(bytes) {
+    return '0x' + bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Fetch bridge claim proof from Pod RPC.
+ *
+ * Calls the `pod_getBridgeClaimProof` RPC method with the deposit transaction hash
+ * and returns the proof data formatted for use with the ETH bridge claim function.
+ *
+ * @param podProvider A JsonRpcProvider connected to the Pod RPC
+ * @param depositTxHash The deposit transaction hash on Pod
+ * @returns Formatted proof data ready for the claim call
+ */
+async function getBridgeClaimProof(podProvider, depositTxHash) {
+    const response = await podProvider.send('pod_getBridgeClaimProof', [depositTxHash]);
+    return {
+        proof: bytesToHex(response.proof),
+        committeeEpoch: response.committee_epoch,
+        auxTxSuffix: bytesToHex(response.aux_tx_suffix),
+    };
+}

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

@@ -1,11 +1,7 @@
 /**
  * @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
+ * The new bridge uses pod_getBridgeClaimProof RPC for claim proofs.
+ * See bridge-claim-proof.helper.ts for the new helper.
  */
 export declare const convertFFICertifiedLog: (_ffi: unknown) => never;

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

@@ -2,18 +2,14 @@
 /**
  * @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
+ * The new bridge uses pod_getBridgeClaimProof RPC for claim proofs.
+ * See bridge-claim-proof.helper.ts for the new helper.
  */
 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.');
+    console.warn('[DEPRECATED] convertFFICertifiedLog is deprecated. Use getBridgeClaimProof instead.');
+    throw new Error('CertifiedLog format is no longer supported. Use ClaimProofData with proof from pod_getBridgeClaimProof.');
 };
 exports.convertFFICertifiedLog = convertFFICertifiedLog;

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

@@ -69,13 +69,12 @@ export interface UnsignedTransaction {
  *
  * 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)
+ * 2. Call pod_getBridgeClaimProof(depositTxHash) to get proof
+ * 3. User claims on ETH: eth_bridge.claim(eth_token, amount, recipient, proof, auxTxSuffix)
  *
  * 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
+ * - Use getBridgeClaimProof helper or call pod_getBridgeClaimProof RPC directly
  */
 export interface ClaimProofData {
     /** Token address on ETH to claim (different from Pod token address) */
@@ -84,17 +83,55 @@ export interface ClaimProofData {
     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;
+    /** Hex-encoded proof bytes from pod_getBridgeClaimProof */
+    proof: string;
+    /** Hex-encoded aux_tx_suffix bytes from pod_getBridgeClaimProof */
+    auxTxSuffix: string;
+}
+/**
+ * Raw response from pod_getBridgeClaimProof RPC method
+ */
+export interface BridgeClaimProofResponse {
+    proof: number[];
+    committee_epoch: number;
+    aux_tx_suffix: number[];
+}
+/**
+ * Attestation from a validator (POD-specific)
+ * From: eth_getTransactionReceipt result.pod_metadata.attestations[]
+ */
+export interface RpcAttestation {
+    validator_address: string;
+    sequence_number: number;
+    batch_index: number;
+    timestamp: number;
+    signature: string;
+}
+/**
+ * POD metadata from receipt
+ * From: eth_getTransactionReceipt result.pod_metadata
+ */
+export interface RpcPodMetadata {
+    attestations: RpcAttestation[];
+    committee_epoch: number;
+}
+/**
+ * Raw eth_getTransactionReceipt response for POD chain
+ */
+export interface RpcPodTransactionReceipt {
+    type: string;
+    status: string;
+    cumulativeGasUsed: string;
+    logs: any[];
+    logsBloom: string;
+    transactionHash: string;
+    transactionIndex: string;
+    blockHash: string;
+    blockNumber: string;
+    gasUsed: string;
+    effectiveGasPrice: string;
+    from: string;
+    to: string;
+    contractAddress: string | null;
+    pod_metadata: RpcPodMetadata;
 }

package/package.json

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

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

@@ -1,161 +0,0 @@
-import { PodTransactionReceipt } from '../pod-sdk/src/types/responses';
-/**
- * Parse a DER-encoded ECDSA signature to extract r and s components.
- *
- * DER format:
- * 0x30 [total-length] 0x02 [r-length] [r] 0x02 [s-length] [s]
- *
- * Example: 3044022020749ca9...0220292484ed...
- * - 30 = SEQUENCE tag
- * - 44 = total length (68 bytes)
- * - 02 = INTEGER tag for r
- * - 20 = r length (32 bytes)
- * - [32 bytes of r]
- * - 02 = INTEGER tag for s
- * - 20 = s length (32 bytes)
- * - [32 bytes of s]
- *
- * @param derSignature The DER-encoded signature as hex string
- * @returns Object with r and s as 32-byte hex strings (0x prefixed)
- */
-export declare function parseDerSignature(derSignature: string): {
-    r: string;
-    s: string;
-};
-/**
- * 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.
- *
- * Receipt format:
- * - attested_tx.hash: The transaction hash that was signed
- * - signatures: Object with numeric keys containing DER-encoded signatures
- *
- * @param receipt The Pod transaction receipt
- * @param msgHash Optional override for the message hash (defaults to attested_tx.hash)
- * @param committeePublicKeys Optional array of validator public keys for v-value recovery
- * @returns Concatenated 65-byte signatures (r || s || v for each signature)
- */
-export declare function extractAggregatedSignatures(receipt: PodTransactionReceipt, msgHash?: string, committeePublicKeys?: string[]): string;
-/**
- * Recover a 65-byte signature without knowing the public key.
- * Tries both v values (27 and 28) and returns the first valid recovery.
- *
- * WARNING: This is less secure as we can't verify the signer.
- * Use recoverSignature65B with public key when possible.
- *
- * @param r The r component
- * @param s The s component
- * @param msgHash The message hash
- * @returns The 65-byte signature with v=27 (tries 27 first, then 28)
- */
-export declare function recoverSignatureWithoutPubkey(r: string, s: string, msgHash: string): string;
-/**
- * Recover a 65-byte signature by checking which v-value recovers to a known validator address.
- *
- * @param r The r component
- * @param s The s component
- * @param msgHash The message hash
- * @param validatorAddresses Set of known validator addresses (lowercase)
- * @returns Object with signature and recovered address, or null if no validator match
- */
-export declare function recoverSignatureWithValidators(r: string, s: string, msgHash: string, validatorAddresses: Set<string>): {
-    signature: string;
-    recoveredAddress: string;
-} | null;
-/**
- * Decompress a compressed secp256k1 public key (33 bytes) to uncompressed format.
- * Compressed format: 02/03 prefix + 32-byte x coordinate
- * Uncompressed format: 04 prefix + 32-byte x + 32-byte y
- *
- * @param compressedPubKey The compressed public key (66 hex chars with 02/03 prefix)
- * @returns The uncompressed public key (130 hex chars with 04 prefix)
- */
-export declare function decompressPublicKey(compressedPubKey: string): string;
-/**
- * Extract aggregated 65-byte signatures using validator public keys for v-value recovery.
- * Committee format: Array of [index, compressed_public_key] tuples
- *
- * @param receipt The Pod transaction receipt
- * @param validators Array of [index, compressedPubKey] tuples from pod_getCommittee
- * @param msgHash Optional override for the message hash
- * @returns Concatenated 65-byte signatures (r || s || v for each signature)
- */
-export declare function extractAggregatedSignaturesWithValidators(receipt: PodTransactionReceipt, validators: [number, string][], msgHash?: string): string;
-/**
- * Extract signature info from Pod receipt for debugging/verification.
- *
- * @param receipt The Pod transaction receipt
- * @param msgHash Optional override for the message hash
- * @returns Array of signature info with recovered 65-byte signatures
- */
-export declare function extractSignatureInfo(receipt: PodTransactionReceipt, msgHash?: string): Array<{
-    index: number;
-    derSignature: string;
-    r: string;
-    s: string;
-    signature65: string;
-}>;