@1llet.xyz/erc4337-gasless-sdk 0.4.14 → 0.4.19

package/dist/index.mjs

@@ -1742,16 +1742,13 @@ var CCTPStrategy = class {
       mintRecipient: recipient
     };
     return processCCTPSettlement(
-      paymentPayload,
-      sourceChain,
-      amount,
-      crossChainConfig,
-      context.facilitatorPrivateKey,
-      recipient
+      context,
+      crossChainConfig
     );
   }
 };
-async function processCCTPSettlement(paymentPayload, sourceChain, amount, crossChainConfig, facilitatorPrivateKey, recipient) {
+async function processCCTPSettlement(context, crossChainConfig) {
+  const { paymentPayload, sourceChain, amount, recipient, facilitatorPrivateKey, depositTxHash } = context;
   if (!facilitatorPrivateKey) {
     return {
       success: false,
@@ -1765,45 +1762,56 @@ async function processCCTPSettlement(paymentPayload, sourceChain, amount, crossC
       errorReason: `Unsupported chain: ${sourceChain}`
     };
   }
-  const { authorization, signature } = paymentPayload;
   const facilitatorAccount = privateKeyToAccount(facilitatorPrivateKey);
+  const { authorization } = paymentPayload;
+  const usdcAddress = networkConfig.usdc;
+  const amountBigInt = BigInt(Math.floor(parseFloat(amount) * 1e6));
   const publicClient = createPublicClient({
     chain: networkConfig.chain,
     transport: http(networkConfig.rpcUrl)
   });
-  const walletClient = createWalletClient({
-    account: facilitatorAccount,
-    chain: networkConfig.chain,
-    transport: http(networkConfig.rpcUrl)
-  });
-  const { v, r, s } = parseSignature(signature);
-  let transferHash;
-  try {
-    transferHash = await walletClient.writeContract({
-      chain: networkConfig.chain,
-      address: networkConfig.usdc,
+  if (depositTxHash) {
+    console.log(`[CCTP] Verifying deposit hash: ${depositTxHash}`);
+    try {
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: depositTxHash });
+      if (receipt.status !== "success") {
+        throw new Error("Deposit transaction failed on-chain");
+      }
+    } catch (e) {
+      return {
+        success: false,
+        errorReason: `Invalid deposit transaction: ${e instanceof Error ? e.message : "Unknown error"}`
+      };
+    }
+  }
+  let facilitatorBalance = BigInt(0);
+  const maxRetries = depositTxHash ? 5 : 1;
+  for (let i = 0; i < maxRetries; i++) {
+    facilitatorBalance = await publicClient.readContract({
+      address: usdcAddress,
       abi: usdcErc3009Abi,
-      functionName: "transferWithAuthorization",
-      args: [
-        authorization.from,
-        authorization.to,
-        BigInt(authorization.value),
-        BigInt(authorization.validAfter),
-        BigInt(authorization.validBefore),
-        authorization.nonce,
-        Number(v),
-        r,
-        s
-      ]
+      functionName: "balanceOf",
+      args: [facilitatorAccount.address]
     });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: transferHash });
-    if (receipt.status !== "success") throw new Error("Transfer execution failed");
-  } catch (error) {
+    if (facilitatorBalance >= amountBigInt) break;
+    if (depositTxHash) await new Promise((r) => setTimeout(r, 2e3));
+  }
+  if (facilitatorBalance < amountBigInt) {
     return {
-      success: false,
-      errorReason: error instanceof Error ? error.message : "Transfer failed"
+      success: true,
+      data: {
+        depositAddress: facilitatorAccount.address,
+        amountToDeposit: amountBigInt.toString(),
+        chainId: networkConfig.chainId
+      },
+      attestation: {
+        message: "PENDING_USER_DEPOSIT",
+        attestation: "0x"
+      },
+      transactionHash: "PENDING_USER_DEPOSIT"
     };
   }
+  const transferHash = depositTxHash || "0x0000000000000000000000000000000000000000000000000000000000000000";
   return executeCCTPBridge(sourceChain, amount, crossChainConfig, facilitatorPrivateKey, recipient, transferHash, authorization.from);
 }
 async function executeCCTPBridge(sourceChain, amount, crossChainConfig, facilitatorPrivateKey, recipient, transferHash, payerAddress) {
@@ -1826,8 +1834,16 @@ async function executeCCTPBridge(sourceChain, amount, crossChainConfig, facilita
   });
   const amountBigInt = BigInt(Math.floor(parseFloat(amount) * 1e6));
   const fee = calculateFee();
+  const minRequired = fee * BigInt(2);
+  if (amountBigInt <= minRequired) {
+    return {
+      success: false,
+      transactionHash: transferHash,
+      errorReason: `Amount too small. Minimum required: ${Number(minRequired) / 1e6} USDC (to cover bridge fees)`
+    };
+  }
   let facilitatorBalance = BigInt(0);
-  const maxRetries = 10;
+  const maxRetries = 2;
   for (let i = 0; i < maxRetries; i++) {
     facilitatorBalance = await publicClient.readContract({
       address: networkConfig.usdc,