@palindromepay/sdk 1.9.8 → 2.0.0

package/dist/PalindromePaySDK.d.ts

@@ -86,7 +86,8 @@ export declare enum SDKErrorCode {
     RPC_ERROR = "RPC_ERROR",
     EVIDENCE_ALREADY_SUBMITTED = "EVIDENCE_ALREADY_SUBMITTED",
     ESCROW_NOT_FOUND = "ESCROW_NOT_FOUND",
-    ALREADY_ACCEPTED = "ALREADY_ACCEPTED"
+    ALREADY_ACCEPTED = "ALREADY_ACCEPTED",
+    SIGNATURE_INVALID = "SIGNATURE_INVALID"
 }
 export type EscrowWalletClient = WalletClient<Transport, Chain, Account>;
 export declare class SDKError extends Error {
@@ -235,7 +236,6 @@ export declare class PalindromePaySDK {
     /** Cache for token decimals (rarely changes, no eviction needed) */
     private tokenDecimalsCache;
     /** Cache for immutable contract values */
-    private walletBytecodeHashCache;
     private feeReceiverCache;
     /** Cached multicall support status per chain (null = not yet detected) */
     private multicallSupported;
@@ -332,6 +332,11 @@ export declare class PalindromePaySDK {
      * Used for: deposit, confirmDelivery, requestCancel, submitArbiterDecision
      */
     signWalletAuthorization(walletClient: EscrowWalletClient, walletAddress: Address, escrowId: bigint): Promise<Hex>;
+    /**
+     * Verify a wallet authorization signature locally before submitting transaction
+     * This ensures the signature is cryptographically valid for the expected signer
+     */
+    private verifyWalletSignature;
     /**
      * Sign a confirm delivery message (for gasless meta-tx)
      */
@@ -350,6 +355,7 @@ export declare class PalindromePaySDK {
     isSignatureDeadlineExpired(deadline: bigint, safetySeconds?: number): boolean;
     /**
      * Predict the wallet address for a given escrow ID (before creation)
+     * Uses CREATE2 address computation: keccak256(0xff ++ deployer ++ salt ++ initCodeHash)
      */
     predictWalletAddress(escrowId: bigint): Promise<Address>;
     /**
@@ -489,6 +495,7 @@ export declare class PalindromePaySDK {
         escrowId: bigint;
         txHash: Hex;
         walletAddress: Address;
+        signatureValid: boolean;
     }>;
     /**
      * Create a new escrow and deposit funds as the buyer (single transaction)
@@ -518,6 +525,7 @@ export declare class PalindromePaySDK {
         escrowId: bigint;
         txHash: Hex;
         walletAddress: Address;
+        signatureValid: boolean;
     }>;
     /**
      * Deposit funds into an existing escrow as the buyer
@@ -531,13 +539,16 @@ export declare class PalindromePaySDK {
      *
      * @param walletClient - The buyer's wallet client (must have account connected)
      * @param escrowId - The escrow ID to deposit into
-     * @returns Transaction hash
+     * @returns Object containing transaction hash and signature validity
      * @throws {SDKError} WALLET_NOT_CONNECTED - If wallet client is not connected
      * @throws {SDKError} NOT_BUYER - If caller is not the designated buyer
      * @throws {SDKError} INVALID_STATE - If escrow is not in AWAITING_PAYMENT state
      * @throws {SDKError} INSUFFICIENT_BALANCE - If buyer has insufficient token balance
      */
-    deposit(walletClient: EscrowWalletClient, escrowId: bigint): Promise<Hex>;
+    deposit(walletClient: EscrowWalletClient, escrowId: bigint): Promise<{
+        txHash: Hex;
+        signatureValid: boolean;
+    }>;
     /**
      * Accept an escrow as the seller (for buyer-created escrows)
      *
@@ -549,13 +560,16 @@ export declare class PalindromePaySDK {
      *
      * @param walletClient - The seller's wallet client (must have account connected)
      * @param escrowId - The escrow ID to accept
-     * @returns Transaction hash
+     * @returns Object containing transaction hash and signature validity
      * @throws {SDKError} WALLET_NOT_CONNECTED - If wallet client is not connected
      * @throws {SDKError} NOT_SELLER - If caller is not the designated seller
      * @throws {SDKError} INVALID_STATE - If escrow is not in AWAITING_DELIVERY state
      * @throws {SDKError} ALREADY_ACCEPTED - If escrow was already accepted
      */
-    acceptEscrow(walletClient: EscrowWalletClient, escrowId: bigint): Promise<Hex>;
+    acceptEscrow(walletClient: EscrowWalletClient, escrowId: bigint): Promise<{
+        txHash: Hex;
+        signatureValid: boolean;
+    }>;
     /**
      * Confirm delivery and release funds to the seller
      *

package/dist/PalindromePaySDK.js

@@ -130,6 +130,7 @@ var SDKErrorCode;
     SDKErrorCode["EVIDENCE_ALREADY_SUBMITTED"] = "EVIDENCE_ALREADY_SUBMITTED";
     SDKErrorCode["ESCROW_NOT_FOUND"] = "ESCROW_NOT_FOUND";
     SDKErrorCode["ALREADY_ACCEPTED"] = "ALREADY_ACCEPTED";
+    SDKErrorCode["SIGNATURE_INVALID"] = "SIGNATURE_INVALID";
 })(SDKErrorCode || (exports.SDKErrorCode = SDKErrorCode = {}));
 class SDKError extends Error {
     constructor(message, code, details) {
@@ -199,7 +200,6 @@ class PalindromePaySDK {
         /** Cache for token decimals (rarely changes, no eviction needed) */
         this.tokenDecimalsCache = new Map();
         /** Cache for immutable contract values */
-        this.walletBytecodeHashCache = null;
         this.feeReceiverCache = null;
         /** Cached multicall support status per chain (null = not yet detected) */
         this.multicallSupported = null;
@@ -574,6 +574,32 @@ class PalindromePaySDK {
         validateSignature(signature, "wallet authorization signature");
         return signature;
     }
+    /**
+     * Verify a wallet authorization signature locally before submitting transaction
+     * This ensures the signature is cryptographically valid for the expected signer
+     */
+    async verifyWalletSignature(signature, walletAddress, escrowId, expectedSigner) {
+        try {
+            return await (0, viem_1.verifyTypedData)({
+                address: expectedSigner,
+                domain: this.getWalletDomain(walletAddress),
+                types: this.walletAuthorizationTypes,
+                primaryType: "WalletAuthorization",
+                message: {
+                    escrowId,
+                    wallet: walletAddress,
+                    participant: expectedSigner,
+                },
+                signature,
+            });
+        }
+        catch (error) {
+            this.log('warn', 'Signature verification failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
     /**
      * Sign a confirm delivery message (for gasless meta-tx)
      */
@@ -645,24 +671,28 @@ class PalindromePaySDK {
     // ==========================================================================
     /**
      * Predict the wallet address for a given escrow ID (before creation)
+     * Uses CREATE2 address computation: keccak256(0xff ++ deployer ++ salt ++ initCodeHash)
      */
     async predictWalletAddress(escrowId) {
-        const salt = (0, viem_1.keccak256)((0, viem_1.pad)((0, viem_1.toBytes)(escrowId), { size: 32 }));
-        // Get wallet bytecode hash from contract (cached - immutable value)
-        if (!this.walletBytecodeHashCache) {
-            this.walletBytecodeHashCache = await this.publicClient.readContract({
-                address: this.contractAddress,
-                abi: this.abiEscrow,
-                functionName: "WALLET_BYTECODE_HASH",
-            });
-        }
-        // Compute CREATE2 address
+        // Salt is keccak256 of the escrowId padded to 32 bytes
+        const salt = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: "uint256" }], [escrowId]));
+        // Get wallet bytecode from the ABI JSON
+        const walletBytecode = PalindromePayWallet_json_1.default.bytecode;
+        // Encode constructor arguments: (address _escrowContract, uint256 _escrowId)
         const encodedArgs = (0, viem_1.encodeAbiParameters)([{ type: "address" }, { type: "uint256" }], [this.contractAddress, escrowId]);
-        // Note: For accurate prediction, need actual bytecode + args hash
-        // This is a simplified version - in production, use the contract's computation
-        const initCodeHash = (0, viem_1.keccak256)((PalindromePayWallet_json_1.default.bytecode + encodedArgs.slice(2)));
-        const raw = (0, viem_1.keccak256)((`0xff${this.contractAddress.slice(2)}${salt.slice(2)}${initCodeHash.slice(2)}`));
-        return (0, viem_1.getAddress)(`0x${raw.slice(26)}`);
+        // initCode = bytecode + encoded constructor args
+        const initCode = (0, viem_1.concat)([walletBytecode, encodedArgs]);
+        const initCodeHash = (0, viem_1.keccak256)(initCode);
+        // CREATE2 address: keccak256(0xff ++ deployer ++ salt ++ initCodeHash)[12:]
+        const data = (0, viem_1.concat)([
+            "0xff",
+            this.contractAddress,
+            salt,
+            initCodeHash,
+        ]);
+        const hash = (0, viem_1.keccak256)(data);
+        // Take the last 20 bytes (address is derived from bytes 12-31)
+        return (0, viem_1.getAddress)(`0x${hash.slice(26)}`);
     }
     // ==========================================================================
     // ESCROW DATA READING
@@ -1053,6 +1083,11 @@ class PalindromePaySDK {
         const predictedWallet = await this.predictWalletAddress(nextId);
         // Sign wallet authorization
         const sellerWalletSig = await this.signWalletAuthorization(walletClient, predictedWallet, nextId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(sellerWalletSig, predictedWallet, nextId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Seller wallet signature is invalid - cannot create escrow", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Create escrow
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1081,7 +1116,30 @@ class PalindromePaySDK {
         });
         const escrowId = events[0]?.args?.escrowId ?? nextId;
         const deal = await this.getEscrowByIdParsed(escrowId);
-        return { escrowId, txHash: hash, walletAddress: deal.wallet };
+        // Verify seller signature is valid on-chain after creation
+        let sellerSigValid = false;
+        try {
+            sellerSigValid = await this.publicClient.readContract({
+                address: deal.wallet,
+                abi: this.abiWallet,
+                functionName: "isSignatureValid",
+                args: [walletClient.account.address],
+            });
+        }
+        catch (error) {
+            this.log('warn', 'Failed to verify seller signature after escrow creation', {
+                escrowId: escrowId.toString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!sellerSigValid) {
+            this.log('error', 'Seller wallet signature is invalid after escrow creation', {
+                escrowId: escrowId.toString(),
+                seller: walletClient.account.address,
+                wallet: deal.wallet,
+            });
+        }
+        return { escrowId, txHash: hash, walletAddress: deal.wallet, signatureValid: sellerSigValid };
     }
     /**
      * Create a new escrow and deposit funds as the buyer (single transaction)
@@ -1144,6 +1202,11 @@ class PalindromePaySDK {
         const predictedWallet = await this.predictWalletAddress(nextId);
         // Sign wallet authorization
         const buyerWalletSig = await this.signWalletAuthorization(walletClient, predictedWallet, nextId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(buyerWalletSig, predictedWallet, nextId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Buyer wallet signature is invalid - cannot create escrow", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Create escrow and deposit
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1172,7 +1235,30 @@ class PalindromePaySDK {
         });
         const escrowId = events[0]?.args?.escrowId ?? nextId;
         const deal = await this.getEscrowByIdParsed(escrowId);
-        return { escrowId, txHash: hash, walletAddress: deal.wallet };
+        // Verify buyer signature is valid on-chain after creation
+        let buyerSigValid = false;
+        try {
+            buyerSigValid = await this.publicClient.readContract({
+                address: deal.wallet,
+                abi: this.abiWallet,
+                functionName: "isSignatureValid",
+                args: [walletClient.account.address],
+            });
+        }
+        catch (error) {
+            this.log('warn', 'Failed to verify buyer signature after escrow creation', {
+                escrowId: escrowId.toString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!buyerSigValid) {
+            this.log('error', 'Buyer wallet signature is invalid after escrow creation', {
+                escrowId: escrowId.toString(),
+                buyer: walletClient.account.address,
+                wallet: deal.wallet,
+            });
+        }
+        return { escrowId, txHash: hash, walletAddress: deal.wallet, signatureValid: buyerSigValid };
     }
     // ==========================================================================
     // DEPOSIT
@@ -1189,7 +1275,7 @@ class PalindromePaySDK {
      *
      * @param walletClient - The buyer's wallet client (must have account connected)
      * @param escrowId - The escrow ID to deposit into
-     * @returns Transaction hash
+     * @returns Object containing transaction hash and signature validity
      * @throws {SDKError} WALLET_NOT_CONNECTED - If wallet client is not connected
      * @throws {SDKError} NOT_BUYER - If caller is not the designated buyer
      * @throws {SDKError} INVALID_STATE - If escrow is not in AWAITING_PAYMENT state
@@ -1203,8 +1289,13 @@ class PalindromePaySDK {
         this.verifyState(deal, EscrowState.AWAITING_PAYMENT, "deposit");
         // Approve token spending
         await this.approveTokenIfNeeded(walletClient, deal.token, this.contractAddress, deal.amount);
-        // Sign wallet authorization
+        // Sign wallet authorization using the wallet address from the escrow
         const buyerWalletSig = await this.signWalletAuthorization(walletClient, deal.wallet, escrowId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(buyerWalletSig, deal.wallet, escrowId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Buyer wallet signature is invalid - cannot deposit", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Deposit
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1213,7 +1304,30 @@ class PalindromePaySDK {
             args: [escrowId, buyerWalletSig],
         });
         await this.waitForReceipt(hash);
-        return hash;
+        // Verify buyer signature is valid on-chain after deposit
+        let buyerSigValid = false;
+        try {
+            buyerSigValid = await this.publicClient.readContract({
+                address: deal.wallet,
+                abi: this.abiWallet,
+                functionName: "isSignatureValid",
+                args: [walletClient.account.address],
+            });
+        }
+        catch (error) {
+            this.log('warn', 'Failed to verify buyer signature after deposit', {
+                escrowId: escrowId.toString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!buyerSigValid) {
+            this.log('error', 'Buyer wallet signature is invalid after deposit', {
+                escrowId: escrowId.toString(),
+                buyer: walletClient.account.address,
+                wallet: deal.wallet,
+            });
+        }
+        return { txHash: hash, signatureValid: buyerSigValid };
     }
     // ==========================================================================
     // ACCEPT ESCROW (for buyer-created escrows)
@@ -1229,7 +1343,7 @@ class PalindromePaySDK {
      *
      * @param walletClient - The seller's wallet client (must have account connected)
      * @param escrowId - The escrow ID to accept
-     * @returns Transaction hash
+     * @returns Object containing transaction hash and signature validity
      * @throws {SDKError} WALLET_NOT_CONNECTED - If wallet client is not connected
      * @throws {SDKError} NOT_SELLER - If caller is not the designated seller
      * @throws {SDKError} INVALID_STATE - If escrow is not in AWAITING_DELIVERY state
@@ -1245,8 +1359,13 @@ class PalindromePaySDK {
         if (deal.sellerWalletSig && deal.sellerWalletSig !== "0x") {
             throw new SDKError("Escrow already accepted", SDKErrorCode.ALREADY_ACCEPTED);
         }
-        // Sign wallet authorization
+        // Sign wallet authorization using the wallet address from the escrow
         const sellerWalletSig = await this.signWalletAuthorization(walletClient, deal.wallet, escrowId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(sellerWalletSig, deal.wallet, escrowId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Seller wallet signature is invalid - cannot accept escrow", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Accept escrow
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1255,7 +1374,30 @@ class PalindromePaySDK {
             args: [escrowId, sellerWalletSig],
         });
         await this.waitForReceipt(hash);
-        return hash;
+        // Verify seller signature is valid on-chain after accept
+        let sellerSigValid = false;
+        try {
+            sellerSigValid = await this.publicClient.readContract({
+                address: deal.wallet,
+                abi: this.abiWallet,
+                functionName: "isSignatureValid",
+                args: [walletClient.account.address],
+            });
+        }
+        catch (error) {
+            this.log('warn', 'Failed to verify seller signature after accept', {
+                escrowId: escrowId.toString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!sellerSigValid) {
+            this.log('error', 'Seller wallet signature is invalid after accept', {
+                escrowId: escrowId.toString(),
+                seller: walletClient.account.address,
+                wallet: deal.wallet,
+            });
+        }
+        return { txHash: hash, signatureValid: sellerSigValid };
     }
     // ==========================================================================
     // CONFIRM DELIVERY
@@ -1286,6 +1428,11 @@ class PalindromePaySDK {
         this.verifyState(deal, EscrowState.AWAITING_DELIVERY, "confirm delivery");
         // Sign wallet authorization
         const buyerWalletSig = await this.signWalletAuthorization(walletClient, deal.wallet, escrowId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(buyerWalletSig, deal.wallet, escrowId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Buyer wallet signature is invalid - cannot confirm delivery", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Confirm delivery
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1397,6 +1544,11 @@ class PalindromePaySDK {
         }
         // Sign wallet authorization
         const walletSig = await this.signWalletAuthorization(walletClient, deal.wallet, escrowId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(walletSig, deal.wallet, escrowId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Wallet signature is invalid - cannot request cancel", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Request cancel
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,
@@ -1634,6 +1786,11 @@ class PalindromePaySDK {
         this.verifyArbiter(walletClient.account.address, deal);
         // Sign wallet authorization
         const arbiterWalletSig = await this.signWalletAuthorization(walletClient, deal.wallet, escrowId);
+        // Pre-validate signature before submitting transaction
+        const isValidSig = await this.verifyWalletSignature(arbiterWalletSig, deal.wallet, escrowId, walletClient.account.address);
+        if (!isValidSig) {
+            throw new SDKError("Arbiter wallet signature is invalid - cannot submit decision", SDKErrorCode.SIGNATURE_INVALID);
+        }
         // Submit decision
         const hash = await this.resilientWriteContract(walletClient, {
             address: this.contractAddress,