@aptos-labs/cross-chain-core 5.9.0 → 6.0.0

package/dist/index.js

@@ -32,13 +32,15 @@ var index_exports = {};
 __export(index_exports, {
   AptosLocalSigner: () => AptosLocalSigner,
   Context: () => Context,
-  CrossChainCore: () => CrossChainCore,
+  CrossChainCore: () => CrossChainCore2,
+  EVM_CHAIN_NAMES: () => EVM_CHAIN_NAMES,
   EthereumChainIdToMainnetChain: () => EthereumChainIdToMainnetChain,
   EthereumChainIdToTestnetChain: () => EthereumChainIdToTestnetChain,
   Network: () => import_ts_sdk7.Network,
   NetworkToChainId: () => import_ts_sdk6.NetworkToChainId,
   NetworkToNodeAPI: () => import_ts_sdk6.NetworkToNodeAPI,
   SolanaLocalSigner: () => SolanaLocalSigner,
+  TransferError: () => TransferError,
   WithdrawError: () => WithdrawError,
   WormholeProvider: () => WormholeProvider,
   createCCTPRoute: () => createCCTPRoute,
@@ -48,7 +50,8 @@ __export(index_exports, {
   serializeReceipt: () => serializeReceipt,
   signAndSendTransaction: () => signAndSendTransaction,
   testnetChains: () => testnetChains,
-  testnetTokens: () => testnetTokens
+  testnetTokens: () => testnetTokens,
+  validateExpireTimestamp: () => validateExpireTimestamp
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -168,14 +171,43 @@ function deserializeReceipt(obj) {
 
 // src/providers/wormhole/signers/AptosLocalSigner.ts
 var import_ts_sdk = require("@aptos-labs/ts-sdk");
+
+// src/providers/wormhole/types.ts
+function validateExpireTimestamp(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(
+      `getExpireTimestamp returned an invalid value (${value}). Expected a non-negative integer (epoch seconds).`
+    );
+  }
+}
+var TransferError = class extends Error {
+  constructor(message, originChainTxnId, cause) {
+    super(message);
+    this.name = "TransferError";
+    this.originChainTxnId = originChainTxnId;
+    this.cause = cause;
+  }
+};
+var WithdrawError = class extends Error {
+  constructor(message, originChainTxnId, phase, cause) {
+    super(message);
+    this.name = "WithdrawError";
+    this.originChainTxnId = originChainTxnId;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+
+// src/providers/wormhole/signers/AptosLocalSigner.ts
 var AptosLocalSigner = class {
-  constructor(chain, options, wallet, feePayerAccount, dappNetwork) {
+  constructor(chain, options, wallet, feePayerAccount, crossChainCore, onTransactionSigned) {
     this._claimedTransactionHashes = [];
     this._chain = chain;
     this._options = options;
     this._wallet = wallet;
     this._sponsorAccount = feePayerAccount;
-    this._dappNetwork = dappNetwork;
+    this._crossChainCore = crossChainCore;
+    this._onTransactionSigned = onTransactionSigned;
   }
   chain() {
     return this._chain;
@@ -190,19 +222,21 @@ var AptosLocalSigner = class {
     const txHashes = [];
     this._claimedTransactionHashes = [];
     for (const tx of txs) {
+      this._onTransactionSigned?.(tx.description, null);
       const txId = await signAndSendTransaction(
         tx,
         this._wallet,
         this._sponsorAccount,
-        this._dappNetwork
+        this._crossChainCore
       );
+      this._onTransactionSigned?.(tx.description, txId);
       txHashes.push(txId);
       this._claimedTransactionHashes.push(txId);
     }
     return txHashes;
   }
 };
-async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwork) {
+async function signAndSendTransaction(request, wallet, sponsorAccount, crossChainCore) {
   if (!wallet) {
     throw new Error("Wallet is undefined");
   }
@@ -216,14 +250,20 @@ async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwo
       return a;
     }
   });
+  const dappNetwork = crossChainCore._dappConfig.aptosNetwork;
   const aptosConfig = new import_ts_sdk.AptosConfig({
     network: dappNetwork
   });
   const aptos2 = new import_ts_sdk.Aptos(aptosConfig);
+  const expireTimestamp = crossChainCore._dappConfig.getExpireTimestamp?.();
+  if (typeof expireTimestamp !== "undefined") {
+    validateExpireTimestamp(expireTimestamp);
+  }
   const txnToSign = await aptos2.transaction.build.simple({
     data: payload,
     sender: wallet.accountAddress.toString(),
-    withFeePayer: sponsorAccount ? true : false
+    withFeePayer: sponsorAccount ? true : false,
+    ...typeof expireTimestamp !== "undefined" ? { options: { expireTimestamp } } : {}
   });
   const senderAuthenticator = await aptos2.transaction.sign({
     signer: wallet,
@@ -247,6 +287,96 @@ async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwo
   return tx.hash;
 }
 
+// src/providers/wormhole/signers/AptosSigner.ts
+var import_ts_sdk2 = require("@aptos-labs/ts-sdk");
+var import_wallet_standard = require("@aptos-labs/wallet-standard");
+var import_gas_station_client = require("@aptos-labs/gas-station-client");
+async function signAndSendTransaction2(request, wallet, sponsorAccount, dappNetwork, crossChainCore) {
+  if (!wallet) {
+    throw new Error("wallet.sendTransaction is undefined");
+  }
+  const payload = request.transaction;
+  payload.functionArguments = payload.functionArguments.map((a) => {
+    if (a instanceof Uint8Array) {
+      return Array.from(a);
+    } else if (typeof a === "bigint") {
+      return a.toString();
+    } else {
+      return a;
+    }
+  });
+  let aptosConfig;
+  const useGasStation = sponsorAccount && !isAccount(sponsorAccount);
+  if (useGasStation) {
+    const gasStationClient = new import_gas_station_client.GasStationClient({
+      network: dappNetwork,
+      apiKey: sponsorAccount[dappNetwork]
+    });
+    const transactionSubmitter = new import_gas_station_client.GasStationTransactionSubmitter(gasStationClient);
+    aptosConfig = new import_ts_sdk2.AptosConfig({
+      network: dappNetwork,
+      pluginSettings: {
+        TRANSACTION_SUBMITTER: transactionSubmitter
+      }
+    });
+  } else {
+    aptosConfig = new import_ts_sdk2.AptosConfig({
+      network: dappNetwork
+    });
+  }
+  const aptos2 = new import_ts_sdk2.Aptos(aptosConfig);
+  const functionArguments = extractFunctionArguments(
+    payload.functionArguments
+  );
+  const withdrawFunction = "0x5e2d961f06cd27aa07554a39d55f5ce1e58dff35d803c3529b1cd5c4fa3ab584::withdraw::deposit_for_burn";
+  const transactionData = {
+    function: withdrawFunction,
+    functionArguments
+  };
+  const expireTimestamp = crossChainCore?._dappConfig?.getExpireTimestamp?.();
+  if (typeof expireTimestamp !== "undefined") {
+    validateExpireTimestamp(expireTimestamp);
+  }
+  const txnToSign = await aptos2.transaction.build.simple({
+    data: transactionData,
+    sender: (await wallet.features["aptos:account"]?.account()).address.toString(),
+    withFeePayer: sponsorAccount ? true : false,
+    ...typeof expireTimestamp !== "undefined" ? { options: { expireTimestamp } } : {}
+  });
+  const response = await wallet.features["aptos:signTransaction"]?.signTransaction(txnToSign);
+  if (response?.status === import_wallet_standard.UserResponseStatus.REJECTED) {
+    throw new Error("User has rejected the request");
+  }
+  const txnToSubmit = {
+    transaction: txnToSign,
+    senderAuthenticator: response.args
+  };
+  if (sponsorAccount && isAccount(sponsorAccount)) {
+    const feePayerSignerAuthenticator = aptos2.transaction.signAsFeePayer({
+      signer: sponsorAccount,
+      transaction: txnToSign
+    });
+    txnToSubmit.feePayerAuthenticator = feePayerSignerAuthenticator;
+  }
+  const txnSubmitted = await aptos2.transaction.submit.simple(txnToSubmit);
+  const tx = await aptos2.waitForTransaction({
+    transactionHash: txnSubmitted.hash
+  });
+  return tx.hash;
+}
+function extractFunctionArguments(functionArguments) {
+  const deserializer1 = new import_ts_sdk2.Deserializer(functionArguments[0].bcsToBytes());
+  const amount = deserializer1.deserializeU64();
+  const deserializer2 = new import_ts_sdk2.Deserializer(functionArguments[1].bcsToBytes());
+  const destination_domain = deserializer2.deserializeU32();
+  const mint_recipient = new import_ts_sdk2.AccountAddress(functionArguments[2].bcsToBytes());
+  const burn_token = new import_ts_sdk2.AccountAddress(functionArguments[3].bcsToBytes());
+  return [amount, destination_domain, mint_recipient, burn_token];
+}
+function isAccount(obj) {
+  return "accountAddress" in obj;
+}
+
 // src/providers/wormhole/signers/SolanaSigner.ts
 var import_web32 = require("@solana/web3.js");
 var import_web33 = require("@solana/web3.js");
@@ -269,26 +399,40 @@ async function sendAndConfirmTransaction(serializedTx, blockhash, lastValidBlock
   );
   let confirmedTx = null;
   let txSendAttempts = 1;
-  while (!confirmedTx) {
-    confirmedTx = await Promise.race([
-      confirmTransactionPromise,
-      new Promise(
-        (resolve) => setTimeout(() => resolve(null), retryIntervalMs)
-      )
-    ]);
-    if (confirmedTx) break;
-    if (verbose) {
-      console.log(
-        `Tx not confirmed after ${retryIntervalMs * txSendAttempts++}ms, resending`
-      );
+  try {
+    while (!confirmedTx) {
+      confirmedTx = await Promise.race([
+        confirmTransactionPromise,
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), retryIntervalMs)
+        )
+      ]);
+      if (confirmedTx) break;
+      if (verbose) {
+        console.log(
+          `Tx not confirmed after ${retryIntervalMs * txSendAttempts++}ms, resending`
+        );
+      }
+      try {
+        await connection.sendRawTransaction(serializedTx, sendOptions);
+      } catch (e) {
+        if (verbose) {
+          console.error("Failed to resend transaction:", e);
+        }
+      }
     }
-    try {
-      await connection.sendRawTransaction(serializedTx, sendOptions);
-    } catch (e) {
+  } catch (e) {
+    const message = e instanceof Error ? e.message.toLowerCase() : "";
+    if (message.includes("block height exceeded") || message.includes("blockheightexceeded")) {
       if (verbose) {
-        console.error("Failed to resend transaction:", e);
+        console.warn(
+          "Block height exceeded but tx was already sent, returning signature:",
+          signature
+        );
       }
+      return signature;
     }
+    throw e;
   }
   if (confirmedTx.value.err) {
     const errorMessage = formatTransactionError(confirmedTx.value.err);
@@ -469,11 +613,11 @@ async function sleep(timeout) {
 }
 
 // src/providers/wormhole/signers/SolanaSigner.ts
-async function signAndSendTransaction2(request, wallet, options, crossChainCore) {
+async function signAndSendTransaction3(request, wallet, options, crossChainCore) {
   if (!wallet || !(wallet instanceof import_derived_wallet_solana.SolanaDerivedWallet)) {
     throw new Error("Invalid wallet type or missing Solana wallet");
   }
-  const commitment = options?.commitment ?? "finalized";
+  const commitment = options?.commitment ?? crossChainCore?._dappConfig?.solanaConfig?.commitment ?? "finalized";
   const connection = new import_web33.Connection(
     crossChainCore?._dappConfig?.solanaConfig?.rpc ?? crossChainCore?.CHAINS["Solana"]?.defaultRpc ?? "https://api.devnet.solana.com"
     // Last resort fallback
@@ -523,7 +667,7 @@ async function setPriorityFeeInstructions(connection, blockhash, lastValidBlockH
 
 // src/providers/wormhole/signers/EthereumSigner.ts
 var import_ethers = require("ethers");
-async function signAndSendTransaction3(request, wallet, chainName, options) {
+async function signAndSendTransaction4(request, wallet, chainName) {
   if (!wallet) {
     throw new Error("wallet.sendTransaction is undefined");
   }
@@ -531,8 +675,7 @@ async function signAndSendTransaction3(request, wallet, chainName, options) {
     method: "eth_chainId"
   });
   const actualChainId = parseInt(chainId, 16);
-  if (!actualChainId)
-    throw new Error("No signer found for chain" + chainName);
+  if (!actualChainId) throw new Error("No signer found for chain" + chainName);
   const expectedChainId = request.transaction.chainId ? (0, import_ethers.getBigInt)(request.transaction.chainId) : void 0;
   if (!actualChainId || !expectedChainId || BigInt(actualChainId) !== expectedChainId) {
     throw new Error(
@@ -543,94 +686,44 @@ async function signAndSendTransaction3(request, wallet, chainName, options) {
     wallet.eip1193Provider
   );
   const signer = await provider.getSigner();
-  const response = await signer.sendTransaction(request.transaction);
-  const receipt = await response.wait();
-  return receipt?.hash || "";
-}
-
-// src/providers/wormhole/signers/AptosSigner.ts
-var import_ts_sdk2 = require("@aptos-labs/ts-sdk");
-var import_wallet_standard = require("@aptos-labs/wallet-standard");
-var import_gas_station_client = require("@aptos-labs/gas-station-client");
-async function signAndSendTransaction4(request, wallet, sponsorAccount, dappNetwork) {
-  if (!wallet) {
-    throw new Error("wallet.sendTransaction is undefined");
-  }
-  const payload = request.transaction;
-  payload.functionArguments = payload.functionArguments.map((a) => {
-    if (a instanceof Uint8Array) {
-      return Array.from(a);
-    } else if (typeof a === "bigint") {
-      return a.toString();
-    } else {
-      return a;
+  let response;
+  try {
+    response = await signer.sendTransaction(request.transaction);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const hashMatch = message.match(/"hash":\s*"(0x[a-fA-F0-9]{64})"/);
+    if (hashMatch) {
+      console.warn("Extracted EVM tx hash from error:", hashMatch[1]);
+      return hashMatch[1];
     }
-  });
-  let aptosConfig;
-  const useGasStation = sponsorAccount && !isAccount(sponsorAccount);
-  if (useGasStation) {
-    const gasStationClient = new import_gas_station_client.GasStationClient({
-      network: dappNetwork,
-      apiKey: sponsorAccount[dappNetwork]
-    });
-    const transactionSubmitter = new import_gas_station_client.GasStationTransactionSubmitter(gasStationClient);
-    aptosConfig = new import_ts_sdk2.AptosConfig({
-      network: dappNetwork,
-      pluginSettings: {
-        TRANSACTION_SUBMITTER: transactionSubmitter
-      }
-    });
-  } else {
-    aptosConfig = new import_ts_sdk2.AptosConfig({
-      network: dappNetwork
-    });
-  }
-  const aptos2 = new import_ts_sdk2.Aptos(aptosConfig);
-  const functionArguments = extractFunctionArguments(
-    payload.functionArguments
-  );
-  const withdrawFunction = "0x5e2d961f06cd27aa07554a39d55f5ce1e58dff35d803c3529b1cd5c4fa3ab584::withdraw::deposit_for_burn";
-  const transactionData = {
-    function: withdrawFunction,
-    functionArguments
-  };
-  const txnToSign = await aptos2.transaction.build.simple({
-    data: transactionData,
-    sender: (await wallet.features["aptos:account"]?.account()).address.toString(),
-    withFeePayer: sponsorAccount ? true : false
-  });
-  const response = await wallet.features["aptos:signTransaction"]?.signTransaction(txnToSign);
-  if (response?.status === import_wallet_standard.UserResponseStatus.REJECTED) {
-    throw new Error("User has rejected the request");
+    throw e;
   }
-  const txnToSubmit = {
-    transaction: txnToSign,
-    senderAuthenticator: response.args
-  };
-  if (sponsorAccount && isAccount(sponsorAccount)) {
-    const feePayerSignerAuthenticator = aptos2.transaction.signAsFeePayer({
-      signer: sponsorAccount,
-      transaction: txnToSign
-    });
-    txnToSubmit.feePayerAuthenticator = feePayerSignerAuthenticator;
+  try {
+    const receipt = await response.wait();
+    return receipt?.hash || response.hash || "";
+  } catch (e) {
+    if (e?.code === "TRANSACTION_REPLACED") {
+      if (e.reason === "repriced") {
+        const replacementHash = e.receipt?.hash || e.replacement?.hash;
+        if (replacementHash) {
+          console.warn(
+            "EVM transaction was repriced. Using replacement hash:",
+            replacementHash
+          );
+          return replacementHash;
+        }
+      }
+      throw e;
+    }
+    if (response.hash) {
+      console.warn(
+        "EVM transaction wait failed but tx was submitted:",
+        response.hash
+      );
+      return response.hash;
+    }
+    throw e;
   }
-  const txnSubmitted = await aptos2.transaction.submit.simple(txnToSubmit);
-  const tx = await aptos2.waitForTransaction({
-    transactionHash: txnSubmitted.hash
-  });
-  return tx.hash;
-}
-function extractFunctionArguments(functionArguments) {
-  const deserializer1 = new import_ts_sdk2.Deserializer(functionArguments[0].bcsToBytes());
-  const amount = deserializer1.deserializeU64();
-  const deserializer2 = new import_ts_sdk2.Deserializer(functionArguments[1].bcsToBytes());
-  const destination_domain = deserializer2.deserializeU32();
-  const mint_recipient = new import_ts_sdk2.AccountAddress(functionArguments[2].bcsToBytes());
-  const burn_token = new import_ts_sdk2.AccountAddress(functionArguments[3].bcsToBytes());
-  return [amount, destination_domain, mint_recipient, burn_token];
-}
-function isAccount(obj) {
-  return "accountAddress" in obj;
 }
 
 // src/providers/wormhole/signers/SuiSigner.ts
@@ -653,7 +746,7 @@ async function signAndSendTransaction5(request, wallet) {
 
 // src/providers/wormhole/signers/Signer.ts
 var Signer = class {
-  constructor(chain, address, options, wallet, crossChainCore, sponsorAccount) {
+  constructor(chain, address, options, wallet, crossChainCore, sponsorAccount, onTransactionSigned, trackAsSourceChain = true) {
     this._claimedTransactionHashes = [];
     this._chain = chain;
     this._address = address;
@@ -661,6 +754,8 @@ var Signer = class {
     this._wallet = wallet;
     this._crossChainCore = crossChainCore;
     this._sponsorAccount = sponsorAccount;
+    this._onTransactionSigned = onTransactionSigned;
+    this._trackAsSourceChain = trackAsSourceChain;
   }
   chain() {
     return this._chain.key;
@@ -675,6 +770,7 @@ var Signer = class {
     const txHashes = [];
     this._claimedTransactionHashes = [];
     for (const tx of txs) {
+      this._onTransactionSigned?.(tx.description, null);
       const txId = await signAndSendTransaction6(
         this._chain,
         tx,
@@ -683,6 +779,10 @@ var Signer = class {
         this._crossChainCore,
         this._sponsorAccount
       );
+      if (this._trackAsSourceChain) {
+        this._crossChainCore._lastSourceChainTxId = txId;
+      }
+      this._onTransactionSigned?.(tx.description, txId);
       txHashes.push(txId);
       this._claimedTransactionHashes.push(txId);
     }
@@ -695,7 +795,7 @@ var signAndSendTransaction6 = async (chain, request, wallet, options = {}, cross
   }
   const dappNetwork = crossChainCore._dappConfig.aptosNetwork;
   if (chain.context === "Solana") {
-    const signature = await signAndSendTransaction2(
+    const signature = await signAndSendTransaction3(
       request,
       wallet,
       options,
@@ -703,11 +803,10 @@ var signAndSendTransaction6 = async (chain, request, wallet, options = {}, cross
     );
     return signature;
   } else if (chain.context === "Ethereum") {
-    const tx = await signAndSendTransaction3(
+    const tx = await signAndSendTransaction4(
       request,
       wallet,
-      chain.displayName,
-      options
+      chain.displayName
     );
     return tx;
   } else if (chain.context === "Sui") {
@@ -717,11 +816,12 @@ var signAndSendTransaction6 = async (chain, request, wallet, options = {}, cross
     );
     return tx;
   } else if (chain.context === "Aptos") {
-    const tx = await signAndSendTransaction4(
+    const tx = await signAndSendTransaction2(
       request,
       wallet,
       sponsorAccount,
-      dappNetwork
+      dappNetwork,
+      crossChainCore
     );
     return tx;
   } else {
@@ -757,17 +857,6 @@ async function createCCTPRoute(wh, sourceChain, destChain, tokens) {
   return { route: cctpRoute, request };
 }
 
-// src/providers/wormhole/types.ts
-var WithdrawError = class extends Error {
-  constructor(message, originChainTxnId, phase, cause) {
-    super(message);
-    this.name = "WithdrawError";
-    this.originChainTxnId = originChainTxnId;
-    this.phase = phase;
-    this.cause = cause;
-  }
-};
-
 // src/providers/wormhole/wormhole.ts
 var WormholeProvider = class {
   constructor(core) {
@@ -786,12 +875,22 @@ var WormholeProvider = class {
     }
     const isMainnet = dappNetwork === import_ts_sdk3.Network.MAINNET;
     const platforms = [import_aptos.default, import_solana.default, import_evm.default, import_sui.default];
-    const solanaRpc = this.crossChainCore._dappConfig?.solanaConfig?.rpc ?? this.crossChainCore.CHAINS["Solana"]?.defaultRpc;
+    const dappConfig = this.crossChainCore._dappConfig;
+    const chains = this.crossChainCore.CHAINS;
+    const solanaRpc = dappConfig?.solanaConfig?.rpc ?? chains["Solana"]?.defaultRpc;
+    const suiRpc = dappConfig?.suiConfig?.rpc ?? chains["Sui"]?.defaultRpc;
+    const evmChainsConfig = {};
+    for (const name of EVM_CHAIN_NAMES) {
+      const rpc = dappConfig?.evmConfig?.[name]?.rpc ?? chains[name]?.defaultRpc;
+      if (rpc) {
+        evmChainsConfig[name] = { rpc };
+      }
+    }
     const wh = await (0, import_sdk3.wormhole)(isMainnet ? "Mainnet" : "Testnet", platforms, {
       chains: {
-        Solana: {
-          rpc: solanaRpc
-        }
+        ...solanaRpc ? { Solana: { rpc: solanaRpc } } : {},
+        ...suiRpc ? { Sui: { rpc: suiRpc } } : {},
+        ...evmChainsConfig
       }
     });
     this._wormholeContext = wh;
@@ -842,7 +941,7 @@ var WormholeProvider = class {
     return quote;
   }
   async submitCCTPTransfer(input) {
-    const { sourceChain, wallet, destinationAddress } = input;
+    const { sourceChain, wallet, destinationAddress, onTransactionSigned } = input;
     if (!this._wormholeContext) {
       await this.setWormholeContext(sourceChain);
     }
@@ -868,7 +967,9 @@ var WormholeProvider = class {
       signerAddress,
       {},
       wallet,
-      this.crossChainCore
+      this.crossChainCore,
+      void 0,
+      onTransactionSigned
     );
     logger.log("signer", signer);
     logger.log("wormholeRequest", this.wormholeRequest);
@@ -883,10 +984,15 @@ var WormholeProvider = class {
     return { originChainTxnId: originChainTxnId || "", receipt };
   }
   async claimCCTPTransfer(input) {
-    let { receipt, mainSigner, sponsorAccount } = input;
+    let { receipt, mainSigner, sponsorAccount, onTransactionSigned } = input;
     if (!this.wormholeRoute) {
       throw new Error("Wormhole route not initialized");
     }
+    if (sponsorAccount && !isAccount(sponsorAccount)) {
+      throw new Error(
+        "AptosLocalSigner does not support GasStationApiKey as a sponsor account. Wormhole claim transactions are script-based and cannot be submitted via the gas station. Please provide an Account instance as the sponsor, or omit the sponsor account."
+      );
+    }
     logger.log("mainSigner", mainSigner.accountAddress.toString());
     let retries = 0;
     const maxRetries = 5;
@@ -904,7 +1010,8 @@ var WormholeProvider = class {
                 // the account that signs the "claim" transaction
                 sponsorAccount,
                 // the fee payer account
-                this.crossChainCore._dappConfig?.aptosNetwork
+                this.crossChainCore,
+                onTransactionSigned
               );
               if (import_sdk3.routes.isManual(this.wormholeRoute)) {
                 const circleAttestationReceipt = await this.wormholeRoute.complete(signer, receipt);
@@ -949,12 +1056,21 @@ var WormholeProvider = class {
       });
     }
     let { originChainTxnId, receipt } = await this.submitCCTPTransfer(input);
-    const { destinationChainTxnId } = await this.claimCCTPTransfer({
-      receipt,
-      mainSigner: input.mainSigner,
-      sponsorAccount: input.sponsorAccount
-    });
-    return { originChainTxnId, destinationChainTxnId };
+    try {
+      const { destinationChainTxnId } = await this.claimCCTPTransfer({
+        receipt,
+        mainSigner: input.mainSigner,
+        sponsorAccount: input.sponsorAccount,
+        onTransactionSigned: input.onTransactionSigned
+      });
+      return { originChainTxnId, destinationChainTxnId };
+    } catch (error) {
+      throw new TransferError(
+        error?.message ?? "Transfer claim failed after source-chain burn",
+        originChainTxnId,
+        error
+      );
+    }
   }
   // --- Split withdraw flow: initiateWithdraw + trackWithdraw + claimWithdraw ---
   /**
@@ -963,7 +1079,7 @@ var WormholeProvider = class {
    * Returns a receipt that can be tracked and later claimed.
    */
   async initiateWithdraw(input) {
-    const { wallet, destinationAddress, sponsorAccount } = input;
+    const { wallet, destinationAddress, sponsorAccount, onTransactionSigned } = input;
     if (!this._wormholeContext) {
       throw new Error("Wormhole context not initialized");
     }
@@ -976,7 +1092,8 @@ var WormholeProvider = class {
       {},
       wallet,
       this.crossChainCore,
-      sponsorAccount
+      sponsorAccount,
+      onTransactionSigned
     );
     const wormholeDestAddress = import_sdk3.Wormhole.chainAddress(
       this.destinationChain,
@@ -1034,9 +1151,9 @@ var WormholeProvider = class {
    * Otherwise falls back to the wallet-based Signer (triggers wallet popup).
    */
   async claimWithdraw(input) {
-    const { sourceChain, destinationAddress, receipt } = input;
+    const { claimChain, destinationAddress, receipt } = input;
     const serverClaimUrl = this.crossChainCore._dappConfig?.solanaConfig?.serverClaimUrl;
-    if (sourceChain === "Solana" && serverClaimUrl) {
+    if (claimChain === "Solana" && serverClaimUrl) {
       logger.log("claimWithdraw: using server-side claim via", serverClaimUrl);
       const response = await fetch(serverClaimUrl, {
         method: "POST",
@@ -1044,7 +1161,7 @@ var WormholeProvider = class {
         body: JSON.stringify({
           receipt: serializeReceipt(receipt),
           destinationAddress,
-          sourceChain
+          claimChain
         })
       });
       if (!response.ok) {
@@ -1065,11 +1182,14 @@ var WormholeProvider = class {
       );
     }
     const claimSigner = new Signer(
-      this.getChainConfig(sourceChain),
+      this.getChainConfig(claimChain),
       destinationAddress,
       {},
       input.wallet,
-      this.crossChainCore
+      this.crossChainCore,
+      void 0,
+      input.onTransactionSigned,
+      false
     );
     if (import_sdk3.routes.isManual(this.wormholeRoute)) {
       const circleAttestationReceipt = await this.wormholeRoute.complete(
@@ -1095,12 +1215,20 @@ var WormholeProvider = class {
    * as the flow progresses.
    */
   async withdraw(input) {
-    const { sourceChain, wallet, destinationAddress, sponsorAccount, onPhaseChange } = input;
+    const {
+      sourceChain,
+      wallet,
+      destinationAddress,
+      sponsorAccount,
+      onPhaseChange,
+      onTransactionSigned
+    } = input;
     onPhaseChange?.("initiating");
     const { originChainTxnId, receipt } = await this.initiateWithdraw({
       wallet,
       destinationAddress,
-      sponsorAccount
+      sponsorAccount,
+      onTransactionSigned
     });
     let currentPhase = "tracking";
     try {
@@ -1109,10 +1237,11 @@ var WormholeProvider = class {
       currentPhase = "claiming";
       onPhaseChange?.("claiming");
       const { destinationChainTxnId } = await this.claimWithdraw({
-        sourceChain,
+        claimChain: sourceChain,
         destinationAddress: destinationAddress.toString(),
         receipt: attestedReceipt,
-        wallet
+        wallet,
+        onTransactionSigned
       });
       return { originChainTxnId, destinationChainTxnId };
     } catch (error) {
@@ -1124,6 +1253,59 @@ var WormholeProvider = class {
       );
     }
   }
+  /**
+   * Retries a failed `claimWithdraw` call with configurable exponential backoff.
+   *
+   * Use this when the claim phase of a withdrawal fails (e.g., RPC instability,
+   * network congestion) but the Aptos burn transaction has already been submitted.
+   * The attested receipt can be recovered from the `WithdrawError` thrown by
+   * `withdraw()` and passed directly to this method.
+   *
+   * @example
+   * ```ts
+   * try {
+   *   await provider.withdraw({ ... });
+   * } catch (error) {
+   *   if (error instanceof WithdrawError && error.phase === "claiming") {
+   *     const result = await provider.retryWithdrawClaim({
+   *       sourceChain,
+   *       destinationAddress,
+   *       receipt: attestedReceipt,
+   *       wallet,
+   *       maxRetries: 5,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  async retryWithdrawClaim(input) {
+    const {
+      maxRetries = 5,
+      initialDelayMs = 2e3,
+      backoffMultiplier = 2,
+      ...claimInput
+    } = input;
+    let lastError;
+    let delay = initialDelayMs;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await this.claimWithdraw(claimInput);
+        return { ...result, retriesUsed: attempt };
+      } catch (error) {
+        lastError = error;
+        logger.log(
+          `retryWithdrawClaim: attempt ${attempt + 1}/${maxRetries + 1} failed: ${lastError.message}`
+        );
+        if (attempt < maxRetries) {
+          await (0, import_ts_sdk3.sleep)(delay);
+          delay *= backoffMultiplier;
+        }
+      }
+    }
+    throw new Error(
+      `Claim failed after ${maxRetries + 1} attempts: ${lastError?.message}`
+    );
+  }
   getChainConfig(chain) {
     const chainConfig = this.crossChainCore.CHAINS[chain];
     if (!chainConfig) {
@@ -1144,6 +1326,7 @@ var SolanaLocalSigner = class {
     this.retryIntervalMs = config.retryIntervalMs ?? 5e3;
     this.priorityFeeConfig = config.priorityFeeConfig;
     this.verbose = config.verbose ?? false;
+    this._onTransactionSigned = config.onTransactionSigned;
   }
   chain() {
     return "Solana";
@@ -1162,7 +1345,9 @@ var SolanaLocalSigner = class {
     const txHashes = [];
     this._claimedTransactionHashes = [];
     for (const tx of txs) {
+      this._onTransactionSigned?.(tx.description, null);
       const txId = await this.signAndSendTransaction(tx);
+      this._onTransactionSigned?.(tx.description, txId);
       txHashes.push(txId);
       this._claimedTransactionHashes.push(txId);
     }
@@ -1653,6 +1838,18 @@ var getSuiWalletUSDCBalance = async (walletAddress, aptosNetwork, rpc) => {
 
 // src/CrossChainCore.ts
 var import_ts_sdk6 = require("@aptos-labs/ts-sdk");
+var _evmChainRecord = {
+  Ethereum: true,
+  Sepolia: true,
+  BaseSepolia: true,
+  ArbitrumSepolia: true,
+  Avalanche: true,
+  Base: true,
+  Arbitrum: true,
+  PolygonSepolia: true,
+  Polygon: true
+};
+var EVM_CHAIN_NAMES = Object.keys(_evmChainRecord);
 var EthereumChainIdToTestnetChain = {
   11155111: testnetChains.Sepolia,
   84532: testnetChains.BaseSepolia,
@@ -1667,7 +1864,7 @@ var EthereumChainIdToMainnetChain = {
   43114: mainnetChains.Avalanche,
   137: mainnetChains.Polygon
 };
-var CrossChainCore = class {
+var CrossChainCore2 = class {
   constructor(args) {
     this._dappConfig = {
       aptosNetwork: import_ts_sdk5.Network.TESTNET
@@ -1721,14 +1918,13 @@ var CrossChainCore = class {
           walletAddress,
           this._dappConfig.aptosNetwork,
           sourceChain,
-          // TODO: maybe let the user config it
-          this.CHAINS[sourceChain].defaultRpc
+          this._dappConfig?.evmConfig?.[sourceChain]?.rpc ?? this.CHAINS[sourceChain].defaultRpc
         );
       case "Sui":
         return await getSuiWalletUSDCBalance(
           walletAddress,
           this._dappConfig.aptosNetwork,
-          this.CHAINS[sourceChain].defaultRpc
+          this._dappConfig?.suiConfig?.rpc ?? this.CHAINS[sourceChain].defaultRpc
         );
       default:
         throw new Error(`Unsupported chain: ${sourceChain}`);
@@ -1743,12 +1939,14 @@ var import_ts_sdk7 = require("@aptos-labs/ts-sdk");
   AptosLocalSigner,
   Context,
   CrossChainCore,
+  EVM_CHAIN_NAMES,
   EthereumChainIdToMainnetChain,
   EthereumChainIdToTestnetChain,
   Network,
   NetworkToChainId,
   NetworkToNodeAPI,
   SolanaLocalSigner,
+  TransferError,
   WithdrawError,
   WormholeProvider,
   createCCTPRoute,
@@ -1758,6 +1956,7 @@ var import_ts_sdk7 = require("@aptos-labs/ts-sdk");
   serializeReceipt,
   signAndSendTransaction,
   testnetChains,
-  testnetTokens
+  testnetTokens,
+  validateExpireTimestamp
 });
 //# sourceMappingURL=index.js.map