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

package/dist/index.mjs

@@ -3,9 +3,8 @@ import { Network as Network3 } from "@aptos-labs/ts-sdk";
 
 // src/providers/wormhole/wormhole.ts
 import {
-  chainToPlatform,
-  routes,
-  Wormhole,
+  routes as routes3,
+  Wormhole as Wormhole2,
   wormhole,
   TransferState
 } from "@wormhole-foundation/sdk";
@@ -34,19 +33,134 @@ var logger = {
   }
 };
 
+// src/utils/receiptSerialization.ts
+import {
+  UniversalAddress
+} from "@wormhole-foundation/sdk";
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function serializeReceipt(receipt) {
+  return JSON.parse(
+    JSON.stringify(receipt, (_key, value) => {
+      if (typeof value === "bigint") {
+        return { __type: "bigint", value: value.toString() };
+      }
+      if (value instanceof UniversalAddress) {
+        return {
+          __type: "UniversalAddress",
+          value: uint8ArrayToBase64(value.toUint8Array())
+        };
+      }
+      if (value instanceof Uint8Array) {
+        return {
+          __type: "Uint8Array",
+          value: uint8ArrayToBase64(value)
+        };
+      }
+      return value;
+    })
+  );
+}
+function deserializeReceipt(obj) {
+  function revive(value, key) {
+    if (value && typeof value === "object") {
+      const objValue = value;
+      if ("__type" in objValue) {
+        if (objValue.__type === "bigint") {
+          return BigInt(objValue.value);
+        }
+        if (objValue.__type === "UniversalAddress") {
+          return new UniversalAddress(
+            base64ToUint8Array(objValue.value)
+          );
+        }
+        if (objValue.__type === "Uint8Array") {
+          return base64ToUint8Array(objValue.value);
+        }
+      }
+      const addressFields = [
+        "sender",
+        "recipient",
+        "destinationCaller",
+        "burnToken",
+        "mintRecipient",
+        "messageSender"
+      ];
+      if (key && addressFields.includes(key) && "address" in objValue) {
+        const addressBytes = revive(objValue.address);
+        if (addressBytes instanceof Uint8Array) {
+          return new UniversalAddress(addressBytes);
+        }
+      }
+      if (Array.isArray(value)) {
+        return value.map((v, i) => revive(v, String(i)));
+      }
+      const result = {};
+      for (const k in objValue) {
+        result[k] = revive(objValue[k], k);
+      }
+      return result;
+    }
+    return value;
+  }
+  return revive(obj);
+}
+
 // src/providers/wormhole/signers/AptosLocalSigner.ts
 import {
   Aptos,
   AptosConfig
 } from "@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._claimedTransactionHashes = "";
-    this._dappNetwork = dappNetwork;
+    this._crossChainCore = crossChainCore;
+    this._onTransactionSigned = onTransactionSigned;
   }
   chain() {
     return this._chain;
@@ -55,24 +169,27 @@ var AptosLocalSigner = class {
     return this._wallet.accountAddress.toString();
   }
   claimedTransactionHashes() {
-    return this._claimedTransactionHashes;
+    return this._claimedTransactionHashes.join(",");
   }
   async signAndSend(txs) {
     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 = 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");
   }
@@ -86,14 +203,20 @@ async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwo
       return a;
     }
   });
+  const dappNetwork = crossChainCore._dappConfig.aptosNetwork;
   const aptosConfig = new AptosConfig({
     network: dappNetwork
   });
   const aptos2 = new 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,
@@ -117,126 +240,241 @@ async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwo
   return tx.hash;
 }
 
+// src/providers/wormhole/signers/AptosSigner.ts
+import {
+  AccountAddress,
+  Aptos as Aptos2,
+  AptosConfig as AptosConfig2,
+  Deserializer
+} from "@aptos-labs/ts-sdk";
+import { UserResponseStatus } from "@aptos-labs/wallet-standard";
+import { GasStationClient, GasStationTransactionSubmitter } from "@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 GasStationClient({
+      network: dappNetwork,
+      apiKey: sponsorAccount[dappNetwork]
+    });
+    const transactionSubmitter = new GasStationTransactionSubmitter(gasStationClient);
+    aptosConfig = new AptosConfig2({
+      network: dappNetwork,
+      pluginSettings: {
+        TRANSACTION_SUBMITTER: transactionSubmitter
+      }
+    });
+  } else {
+    aptosConfig = new AptosConfig2({
+      network: dappNetwork
+    });
+  }
+  const aptos2 = new Aptos2(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 === 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 Deserializer(functionArguments[0].bcsToBytes());
+  const amount = deserializer1.deserializeU64();
+  const deserializer2 = new Deserializer(functionArguments[1].bcsToBytes());
+  const destination_domain = deserializer2.deserializeU32();
+  const mint_recipient = new AccountAddress(functionArguments[2].bcsToBytes());
+  const burn_token = new 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
+import {
+  Transaction as Transaction2
+} from "@solana/web3.js";
+import { Connection as Connection2 } from "@solana/web3.js";
+import { SolanaDerivedWallet } from "@aptos-labs/derived-wallet-solana";
+
+// src/providers/wormhole/signers/solanaUtils.ts
 import {
   ComputeBudgetProgram,
   LAMPORTS_PER_SOL
 } from "@solana/web3.js";
-import { Transaction } from "@solana/web3.js";
 import {
   determinePriorityFee,
   determinePriorityFeeTritonOne
 } from "@wormhole-foundation/sdk-solana";
-import { Connection } from "@solana/web3.js";
-import { SolanaDerivedWallet } from "@aptos-labs/derived-wallet-solana";
-async function signAndSendTransaction2(request, wallet, options, crossChainCore) {
-  if (!wallet || !(wallet instanceof SolanaDerivedWallet)) {
-    throw new Error("Invalid wallet type or missing Solana wallet").message;
-  }
-  const commitment = options?.commitment ?? "finalized";
-  const connection = new Connection(
-    crossChainCore?._dappConfig?.solanaConfig?.rpc ?? crossChainCore?.CHAINS["Solana"]?.defaultRpc ?? "https://api.devnet.solana.com"
-    // Last resort fallback
-  );
-  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment);
-  const unsignedTx = await setPriorityFeeInstructions(
-    connection,
-    blockhash,
-    lastValidBlockHeight,
-    request,
-    crossChainCore
-  );
-  let confirmTransactionPromise = null;
-  let confirmedTx = null;
-  let txSendAttempts = 1;
-  let signature = "";
-  if (!wallet.solanaWallet.signTransaction) {
-    throw new Error("Wallet does not support signing transactions").message;
-  }
-  const tx = await wallet.solanaWallet.signTransaction(unsignedTx);
-  if (!tx) throw new Error("Failed to sign transaction").message;
-  if (request.transaction.signers && tx instanceof Transaction) {
-    tx.partialSign(...request.transaction.signers);
-  }
-  const serializedTx = tx.serialize();
+async function sendAndConfirmTransaction(serializedTx, blockhash, lastValidBlockHeight, config) {
+  const { connection, commitment, retryIntervalMs = 5e3, verbose = false } = config;
   const sendOptions = {
     skipPreflight: true,
     maxRetries: 0,
-    preFlightCommitment: commitment
-    // See PR and linked issue for why setting this matters: https://github.com/anza-xyz/agave/pull/483
+    preflightCommitment: commitment
   };
-  signature = await connection.sendRawTransaction(serializedTx, sendOptions);
-  confirmTransactionPromise = connection.confirmTransaction(
-    {
-      signature,
-      blockhash,
-      lastValidBlockHeight
-    },
+  const signature = await connection.sendRawTransaction(serializedTx, sendOptions);
+  const confirmTransactionPromise = connection.confirmTransaction(
+    { signature, blockhash, lastValidBlockHeight },
     commitment
   );
-  const txRetryInterval = 5e3;
-  while (!confirmedTx) {
-    confirmedTx = await Promise.race([
-      confirmTransactionPromise,
-      new Promise(
-        (resolve) => setTimeout(() => {
-          resolve(null);
-        }, txRetryInterval)
-      )
-    ]);
-    if (confirmedTx) {
-      break;
-    }
-    console.log(
-      `Tx not confirmed after ${txRetryInterval * txSendAttempts++}ms, resending`
-    );
-    try {
-      await connection.sendRawTransaction(serializedTx, sendOptions);
-    } catch (e) {
-      console.error("Failed to resend transaction:", e);
-    }
-  }
-  if (confirmedTx.value.err) {
-    let errorMessage = `Transaction failed: ${confirmedTx.value.err}`;
-    if (typeof confirmedTx.value.err === "object") {
+  let confirmedTx = null;
+  let txSendAttempts = 1;
+  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 {
-        errorMessage = `Transaction failed: ${JSON.stringify(
-          confirmedTx.value.err,
-          (_key, value) => typeof value === "bigint" ? value.toString() : value
-          // Handle bigint props
-        )}`;
+        await connection.sendRawTransaction(serializedTx, sendOptions);
       } catch (e) {
-        errorMessage = `Transaction failed: Unknown error`;
+        if (verbose) {
+          console.error("Failed to resend transaction:", e);
+        }
       }
     }
-    throw new Error(`Transaction failed: ${errorMessage}`).message;
+  } catch (e) {
+    const message = e instanceof Error ? e.message.toLowerCase() : "";
+    if (message.includes("block height exceeded") || message.includes("blockheightexceeded")) {
+      if (verbose) {
+        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);
+    throw new Error(errorMessage);
   }
   return signature;
 }
-async function setPriorityFeeInstructions(connection, blockhash, lastValidBlockHeight, request, crossChainCore) {
-  const unsignedTx = request.transaction.transaction;
+function formatTransactionError(err) {
+  if (typeof err === "object" && err !== null) {
+    try {
+      return `Transaction failed: ${JSON.stringify(
+        err,
+        (_key, value) => typeof value === "bigint" ? value.toString() : value
+      )}`;
+    } catch {
+      return "Transaction failed: Unknown error";
+    }
+  }
+  return `Transaction failed: ${err}`;
+}
+async function addPriorityFeeInstructions(connection, transaction, priorityFeeConfig, verbose = false) {
   const computeBudgetIxFilter = (ix) => ix.programId.toString() !== "ComputeBudget111111111111111111111111111111";
-  unsignedTx.recentBlockhash = blockhash;
-  unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
-  unsignedTx.instructions = unsignedTx.instructions.filter(
-    computeBudgetIxFilter
+  transaction.instructions = transaction.instructions.filter(computeBudgetIxFilter);
+  const instructions = await createPriorityFeeInstructions(
+    connection,
+    transaction,
+    priorityFeeConfig,
+    verbose
   );
-  unsignedTx.add(
-    ...await createPriorityFeeInstructions(
-      connection,
-      unsignedTx,
-      crossChainCore
-    )
+  transaction.add(...instructions);
+  return transaction;
+}
+async function createPriorityFeeInstructions(connection, transaction, priorityFeeConfig, verbose = false) {
+  const unitsUsed = await simulateAndGetComputeUnits(connection, transaction);
+  const unitBudget = Math.floor(unitsUsed * 1.2);
+  const instructions = [];
+  instructions.push(
+    ComputeBudgetProgram.setComputeUnitLimit({
+      units: unitBudget
+    })
   );
-  return unsignedTx;
+  const {
+    percentile = 0.9,
+    percentileMultiple = 1,
+    min = 1e5,
+    max = 1e8
+  } = priorityFeeConfig ?? {};
+  const rpcProvider = determineRpcProvider(connection.rpcEndpoint);
+  const { fee, methodUsed } = await calculatePriorityFee(
+    connection,
+    transaction,
+    rpcProvider,
+    { percentile, percentileMultiple, min, max }
+  );
+  if (verbose) {
+    const maxFeeInSol = fee / 1e6 / LAMPORTS_PER_SOL * unitBudget;
+    console.table({
+      "RPC Provider": rpcProvider,
+      "Method used": methodUsed,
+      "Percentile used": percentile,
+      "Multiple used": percentileMultiple,
+      "Compute budget": unitBudget,
+      "Priority fee": fee,
+      "Max fee in SOL": maxFeeInSol
+    });
+  }
+  instructions.push(
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: fee })
+  );
+  return instructions;
 }
-async function createPriorityFeeInstructions(connection, transaction, crossChainCore) {
+async function simulateAndGetComputeUnits(connection, transaction) {
   let unitsUsed = 2e5;
   let simulationAttempts = 0;
   simulationLoop: while (true) {
-    const response = await connection.simulateTransaction(
-      transaction
-    );
+    const response = await connection.simulateTransaction(transaction);
     if (response.value.err) {
       if (checkKnownSimulationError(response.value)) {
         if (simulationAttempts < 5) {
@@ -253,7 +491,7 @@ async function createPriorityFeeInstructions(connection, transaction, crossChain
         `Simulation failed: ${JSON.stringify(response.value.err)}
 Logs:
 ${(response.value.logs || []).join("\n  ")}`
-      ).message;
+      );
     } else {
       if (response.value.unitsConsumed) {
         unitsUsed = response.value.unitsConsumed;
@@ -261,41 +499,13 @@ ${(response.value.logs || []).join("\n  ")}`
       break;
     }
   }
-  const unitBudget = Math.floor(unitsUsed * 1.2);
-  const instructions = [];
-  instructions.push(
-    ComputeBudgetProgram.setComputeUnitLimit({
-      // Set compute budget to 120% of the units used in the simulated transaction
-      units: unitBudget
-    })
-  );
-  const {
-    percentile = 0.9,
-    percentileMultiple = 1,
-    min = 1e5,
-    max = 1e8
-  } = crossChainCore?._dappConfig?.solanaConfig?.priorityFeeConfig ?? {};
-  const calculateFee = async (rpcProvider2) => {
-    if (rpcProvider2 === "triton") {
-      try {
-        const fee2 = await determinePriorityFeeTritonOne(
-          connection,
-          transaction,
-          percentile,
-          percentileMultiple,
-          min,
-          max
-        );
-        return {
-          fee: fee2,
-          methodUsed: "triton"
-        };
-      } catch (e) {
-        console.warn(`Failed to determine priority fee using Triton RPC:`, e);
-      }
-    }
+  return unitsUsed;
+}
+async function calculatePriorityFee(connection, transaction, rpcProvider, config) {
+  const { percentile, percentileMultiple, min, max } = config;
+  if (rpcProvider === "triton") {
     try {
-      const fee2 = await determinePriorityFee(
+      const fee = await determinePriorityFeeTritonOne(
         connection,
         transaction,
         percentile,
@@ -303,37 +513,25 @@ ${(response.value.logs || []).join("\n  ")}`
         min,
         max
       );
-      return {
-        fee: fee2,
-        methodUsed: "default"
-      };
+      return { fee, methodUsed: "triton" };
     } catch (e) {
       console.warn(`Failed to determine priority fee using Triton RPC:`, e);
-      return {
-        fee: min,
-        methodUsed: "minimum"
-      };
     }
-  };
-  const rpcProvider = determineRpcProvider(connection.rpcEndpoint);
-  const { fee, methodUsed } = await calculateFee(rpcProvider);
-  const maxFeeInSol = fee / // convert microlamports to lamports
-  1e6 / // convert lamports to SOL
-  LAMPORTS_PER_SOL * // multiply by maximum compute units used
-  unitBudget;
-  console.table({
-    "RPC Provider": rpcProvider,
-    "Method used": methodUsed,
-    "Percentile used": percentile,
-    "Multiple used": percentileMultiple,
-    "Compute budget": unitBudget,
-    "Priority fee": fee,
-    "Max fee in SOL": maxFeeInSol
-  });
-  instructions.push(
-    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: fee })
-  );
-  return instructions;
+  }
+  try {
+    const fee = await determinePriorityFee(
+      connection,
+      transaction,
+      percentile,
+      percentileMultiple,
+      min,
+      max
+    );
+    return { fee, methodUsed: "default" };
+  } catch (e) {
+    console.warn(`Failed to determine priority fee:`, e);
+    return { fee: min, methodUsed: "minimum" };
+  }
 }
 function checkKnownSimulationError(response) {
   const errors = {};
@@ -350,159 +548,148 @@ function checkKnownSimulationError(response) {
       }
     }
   }
-  if (isEmptyObject(errors)) {
+  if (Object.keys(errors).length === 0) {
     return false;
   }
   console.table(errors);
   return true;
 }
-async function sleep(timeout) {
-  return new Promise((resolve) => setTimeout(resolve, timeout));
+function isHostOrSubdomainOf(hostname, base) {
+  return hostname === base || hostname.endsWith(`.${base}`);
 }
-var isEmptyObject = (value) => {
-  if (value === null || value === void 0) {
-    return true;
-  }
-  for (const key in value) {
-    if (value.hasOwnProperty.call(value, key)) {
-      return false;
-    }
-  }
-  return true;
-};
 function determineRpcProvider(endpoint) {
   try {
     const url = new URL(endpoint);
     const hostname = url.hostname;
-    if (hostname === "rpcpool.com") {
+    if (isHostOrSubdomainOf(hostname, "rpcpool.com") || isHostOrSubdomainOf(hostname, "triton.one")) {
       return "triton";
-    } else if (hostname === "helius-rpc.com") {
+    } else if (isHostOrSubdomainOf(hostname, "helius-rpc.com") || isHostOrSubdomainOf(hostname, "helius.xyz")) {
       return "helius";
-    } else if (hostname === "rpc.ankr.com") {
+    } else if (isHostOrSubdomainOf(hostname, "ankr.com")) {
       return "ankr";
     } else {
       return "unknown";
     }
-  } catch (e) {
-    return "unknown";
-  }
+  } catch {
+    return "unknown";
+  }
+}
+async function sleep(timeout) {
+  return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+
+// src/providers/wormhole/signers/SolanaSigner.ts
+async function signAndSendTransaction3(request, wallet, options, crossChainCore) {
+  if (!wallet || !(wallet instanceof SolanaDerivedWallet)) {
+    throw new Error("Invalid wallet type or missing Solana wallet");
+  }
+  const commitment = options?.commitment ?? crossChainCore?._dappConfig?.solanaConfig?.commitment ?? "finalized";
+  const connection = new Connection2(
+    crossChainCore?._dappConfig?.solanaConfig?.rpc ?? crossChainCore?.CHAINS["Solana"]?.defaultRpc ?? "https://api.devnet.solana.com"
+    // Last resort fallback
+  );
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment);
+  const unsignedTx = await setPriorityFeeInstructions(
+    connection,
+    blockhash,
+    lastValidBlockHeight,
+    request,
+    crossChainCore?._dappConfig?.solanaConfig?.priorityFeeConfig
+  );
+  if (!wallet.solanaWallet.signTransaction) {
+    throw new Error("Wallet does not support signing transactions");
+  }
+  const tx = await wallet.solanaWallet.signTransaction(unsignedTx);
+  if (!tx) throw new Error("Failed to sign transaction");
+  if (request.transaction.signers && tx instanceof Transaction2) {
+    tx.partialSign(...request.transaction.signers);
+  }
+  const serializedTx = tx.serialize();
+  const signature = await sendAndConfirmTransaction(
+    serializedTx,
+    blockhash,
+    lastValidBlockHeight,
+    {
+      connection,
+      commitment,
+      retryIntervalMs: 5e3,
+      verbose: false
+    }
+  );
+  return signature;
+}
+async function setPriorityFeeInstructions(connection, blockhash, lastValidBlockHeight, request, priorityFeeConfig) {
+  const unsignedTx = request.transaction.transaction;
+  unsignedTx.recentBlockhash = blockhash;
+  unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+  await addPriorityFeeInstructions(
+    connection,
+    unsignedTx,
+    priorityFeeConfig,
+    false
+  );
+  return unsignedTx;
 }
 
 // src/providers/wormhole/signers/EthereumSigner.ts
 import { ethers, getBigInt } from "ethers";
-async function signAndSendTransaction3(request, wallet, chainName, options) {
+async function signAndSendTransaction4(request, wallet, chainName) {
   if (!wallet) {
-    throw new Error("wallet.sendTransaction is undefined").message;
+    throw new Error("wallet.sendTransaction is undefined");
   }
   const chainId = await wallet.eip1193Provider.request({
     method: "eth_chainId"
   });
   const actualChainId = parseInt(chainId, 16);
-  if (!actualChainId)
-    throw new Error("No signer found for chain" + chainName).message;
+  if (!actualChainId) throw new Error("No signer found for chain" + chainName);
   const expectedChainId = request.transaction.chainId ? getBigInt(request.transaction.chainId) : void 0;
   if (!actualChainId || !expectedChainId || BigInt(actualChainId) !== expectedChainId) {
     throw new Error(
       `Signer is not connected to the right chain. Expected ${expectedChainId}, got ${actualChainId}`
-    ).message;
+    );
   }
   const provider = new ethers.BrowserProvider(
     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
-import {
-  AccountAddress,
-  Aptos as Aptos2,
-  AptosConfig as AptosConfig2,
-  Deserializer
-} from "@aptos-labs/ts-sdk";
-import { UserResponseStatus } from "@aptos-labs/wallet-standard";
-import { GasStationClient, GasStationTransactionSubmitter } from "@aptos-labs/gas-station-client";
-async function signAndSendTransaction4(request, wallet, sponsorAccount, dappNetwork) {
-  if (!wallet) {
-    throw new Error("wallet.sendTransaction is undefined").message;
-  }
-  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 GasStationClient({
-      network: dappNetwork,
-      apiKey: sponsorAccount[dappNetwork]
-    });
-    const transactionSubmitter = new GasStationTransactionSubmitter(gasStationClient);
-    aptosConfig = new AptosConfig2({
-      network: dappNetwork,
-      pluginSettings: {
-        TRANSACTION_SUBMITTER: transactionSubmitter
-      }
-    });
-  } else {
-    aptosConfig = new AptosConfig2({
-      network: dappNetwork
-    });
-  }
-  const aptos2 = new Aptos2(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 === 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 Deserializer(functionArguments[0].bcsToBytes());
-  const amount = deserializer1.deserializeU64();
-  const deserializer2 = new Deserializer(functionArguments[1].bcsToBytes());
-  const destination_domain = deserializer2.deserializeU32();
-  const mint_recipient = new AccountAddress(functionArguments[2].bcsToBytes());
-  const burn_token = new 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
@@ -525,14 +712,16 @@ 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;
     this._options = options;
     this._wallet = wallet;
     this._crossChainCore = crossChainCore;
     this._sponsorAccount = sponsorAccount;
-    this._claimedTransactionHashes = "";
+    this._onTransactionSigned = onTransactionSigned;
+    this._trackAsSourceChain = trackAsSourceChain;
   }
   chain() {
     return this._chain.key;
@@ -541,11 +730,13 @@ var Signer = class {
     return this._address;
   }
   claimedTransactionHashes() {
-    return this._claimedTransactionHashes;
+    return this._claimedTransactionHashes.join(",");
   }
   async signAndSend(txs) {
     const txHashes = [];
+    this._claimedTransactionHashes = [];
     for (const tx of txs) {
+      this._onTransactionSigned?.(tx.description, null);
       const txId = await signAndSendTransaction6(
         this._chain,
         tx,
@@ -554,8 +745,12 @@ var Signer = class {
         this._crossChainCore,
         this._sponsorAccount
       );
+      if (this._trackAsSourceChain) {
+        this._crossChainCore._lastSourceChainTxId = txId;
+      }
+      this._onTransactionSigned?.(tx.description, txId);
       txHashes.push(txId);
-      this._claimedTransactionHashes = txId;
+      this._claimedTransactionHashes.push(txId);
     }
     return txHashes;
   }
@@ -566,7 +761,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,
@@ -574,11 +769,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") {
@@ -588,11 +782,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 {
@@ -600,6 +795,38 @@ var signAndSendTransaction6 = async (chain, request, wallet, options = {}, cross
   }
 };
 
+// src/providers/wormhole/utils.ts
+import {
+  chainToPlatform,
+  routes as routes2,
+  Wormhole
+} from "@wormhole-foundation/sdk";
+async function createCCTPRoute(wh, sourceChain, destChain, tokens) {
+  const sourceToken = Wormhole.tokenId(
+    sourceChain,
+    tokens[sourceChain].tokenId.address
+  );
+  const destToken = Wormhole.tokenId(
+    destChain,
+    tokens[destChain].tokenId.address
+  );
+  const destContext = wh.getPlatform(chainToPlatform(destChain)).getChain(destChain);
+  const sourceContext = wh.getPlatform(chainToPlatform(sourceChain)).getChain(sourceChain);
+  const request = await routes2.RouteTransferRequest.create(
+    wh,
+    { source: sourceToken, destination: destToken },
+    sourceContext,
+    destContext
+  );
+  const resolver = wh.resolver([routes2.CCTPRoute]);
+  const foundRoutes = await resolver.findRoutes(request);
+  const cctpRoute = foundRoutes[0];
+  if (!cctpRoute || !routes2.isManual(cctpRoute)) {
+    throw new Error("Expected manual CCTP route");
+  }
+  return { route: cctpRoute, request };
+}
+
 // src/providers/wormhole/wormhole.ts
 var WormholeProvider = class {
   constructor(core) {
@@ -618,12 +845,22 @@ var WormholeProvider = class {
     }
     const isMainnet = dappNetwork === Network.MAINNET;
     const platforms = [aptos, solana, evm, sui];
-    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 wormhole(isMainnet ? "Mainnet" : "Testnet", platforms, {
       chains: {
-        Solana: {
-          rpc: solanaRpc
-        }
+        ...solanaRpc ? { Solana: { rpc: solanaRpc } } : {},
+        ...suiRpc ? { Sui: { rpc: suiRpc } } : {},
+        ...evmChainsConfig
       }
     });
     this._wormholeContext = wh;
@@ -632,33 +869,15 @@ var WormholeProvider = class {
     if (!this._wormholeContext) {
       throw new Error("Wormhole context not initialized");
     }
-    const { sourceToken, destToken } = this.getTokenInfo(
-      sourceChain,
-      destinationChain
-    );
-    const destContext = this._wormholeContext.getPlatform(chainToPlatform(destinationChain)).getChain(destinationChain);
-    const sourceContext = this._wormholeContext.getPlatform(chainToPlatform(sourceChain)).getChain(sourceChain);
-    logger.log("sourceContext", sourceContext);
-    logger.log("sourceToken", sourceToken);
-    logger.log("destContext", destContext);
-    logger.log("destToken", destToken);
-    const request = await routes.RouteTransferRequest.create(
+    const { route: cctpRoute, request } = await createCCTPRoute(
       this._wormholeContext,
-      {
-        source: sourceToken,
-        destination: destToken
-      },
-      sourceContext,
-      destContext
+      sourceChain,
+      destinationChain,
+      this.crossChainCore.TOKENS
     );
-    const resolver = this._wormholeContext.resolver([
-      routes.CCTPRoute
-      // manual CCTP
-    ]);
-    const route = await resolver.findRoutes(request);
-    const cctpRoute = route[0];
     this.wormholeRoute = cctpRoute;
     this.wormholeRequest = request;
+    this.destinationChain = destinationChain;
     return { route: cctpRoute, request };
   }
   async getQuote(input) {
@@ -680,19 +899,19 @@ var WormholeProvider = class {
     const validated = await route.validate(request, transferParams);
     if (!validated.valid) {
       logger.log("invalid", validated.valid);
-      throw new Error(`Invalid quote: ${validated.error}`).message;
+      throw new Error(`Invalid quote: ${validated.error}`);
     }
     const quote = await route.quote(request, validated.params);
     if (!quote.success) {
       logger.log("quote failed", quote.success);
-      throw new Error(`Invalid quote: ${quote.error}`).message;
+      throw new Error(`Invalid quote: ${quote.error}`);
     }
     this.wormholeQuote = quote;
     logger.log("quote", quote);
     return quote;
   }
   async submitCCTPTransfer(input) {
-    const { sourceChain, wallet, destinationAddress } = input;
+    const { sourceChain, wallet, destinationAddress, onTransactionSigned } = input;
     if (!this._wormholeContext) {
       await this.setWormholeContext(sourceChain);
     }
@@ -718,7 +937,9 @@ var WormholeProvider = class {
       signerAddress,
       {},
       wallet,
-      this.crossChainCore
+      this.crossChainCore,
+      void 0,
+      onTransactionSigned
     );
     logger.log("signer", signer);
     logger.log("wormholeRequest", this.wormholeRequest);
@@ -727,16 +948,21 @@ var WormholeProvider = class {
       this.wormholeRequest,
       signer,
       this.wormholeQuote,
-      Wormhole.chainAddress("Aptos", destinationAddress.toString())
+      Wormhole2.chainAddress("Aptos", destinationAddress.toString())
     );
     const originChainTxnId = "originTxs" in receipt ? receipt.originTxs[receipt.originTxs.length - 1].txid : void 0;
     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;
@@ -754,9 +980,10 @@ var WormholeProvider = class {
                 // the account that signs the "claim" transaction
                 sponsorAccount,
                 // the fee payer account
-                this.crossChainCore._dappConfig?.aptosNetwork
+                this.crossChainCore,
+                onTransactionSigned
               );
-              if (routes.isManual(this.wormholeRoute)) {
+              if (routes3.isManual(this.wormholeRoute)) {
                 const circleAttestationReceipt = await this.wormholeRoute.complete(signer, receipt);
                 logger.log("Claim receipt: ", circleAttestationReceipt);
                 const destinationChainTxnId = signer.claimedTransactionHashes();
@@ -799,22 +1026,30 @@ 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 };
-  }
-  async withdraw(input) {
-    const { sourceChain, wallet, destinationAddress, sponsorAccount } = input;
-    logger.log("sourceChain", sourceChain);
-    logger.log("wallet", wallet);
-    logger.log("destinationAddress", destinationAddress);
-    logger.log("sponsorAccount", sponsorAccount);
-    if (!this._wormholeContext) {
-      await this.setWormholeContext(sourceChain);
+    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 ---
+  /**
+   * Phase 1: Initiates a withdraw by burning USDC on Aptos.
+   * The user signs the Aptos burn transaction via their wallet.
+   * Returns a receipt that can be tracked and later claimed.
+   */
+  async initiateWithdraw(input) {
+    const { wallet, destinationAddress, sponsorAccount, onTransactionSigned } = input;
     if (!this._wormholeContext) {
       throw new Error("Wormhole context not initialized");
     }
@@ -823,69 +1058,49 @@ var WormholeProvider = class {
     }
     const signer = new Signer(
       this.getChainConfig("Aptos"),
-      (await input.wallet.features["aptos:account"].account()).address.toString(),
+      (await wallet.features["aptos:account"].account()).address.toString(),
       {},
-      input.wallet,
+      wallet,
       this.crossChainCore,
-      sponsorAccount
+      sponsorAccount,
+      onTransactionSigned
     );
-    logger.log("signer", signer);
-    logger.log("wormholeRequest", this.wormholeRequest);
-    logger.log("wormholeQuote", this.wormholeQuote);
-    logger.log(
-      "Wormhole.chainAddress",
-      Wormhole.chainAddress(sourceChain, input.destinationAddress.toString())
+    const wormholeDestAddress = Wormhole2.chainAddress(
+      this.destinationChain,
+      destinationAddress.toString()
     );
-    let receipt = await this.wormholeRoute.initiate(
+    const receipt = await this.wormholeRoute.initiate(
       this.wormholeRequest,
       signer,
       this.wormholeQuote,
-      Wormhole.chainAddress(sourceChain, input.destinationAddress.toString())
+      wormholeDestAddress
     );
-    logger.log("receipt", receipt);
+    logger.log("initiateWithdraw receipt", receipt);
     const originChainTxnId = "originTxs" in receipt ? receipt.originTxs[receipt.originTxs.length - 1].txid : void 0;
+    return { originChainTxnId: originChainTxnId || "", receipt };
+  }
+  /**
+   * Phase 2: Tracks a withdraw receipt until attestation is ready.
+   * This polls Wormhole and returns once the receipt reaches the Attested state.
+   */
+  async trackWithdraw(receipt) {
+    if (!this.wormholeRoute) {
+      throw new Error("Wormhole route not initialized");
+    }
     let retries = 0;
     const maxRetries = 5;
     const baseDelay = 1e3;
     while (retries < maxRetries) {
       try {
         for await (receipt of this.wormholeRoute.track(receipt, 120 * 1e3)) {
-          if (receipt.state >= TransferState.SourceInitiated) {
-            logger.log("Receipt is on track ", receipt);
-            try {
-              const signer2 = new Signer(
-                this.getChainConfig(sourceChain),
-                destinationAddress.toString(),
-                {},
-                wallet,
-                this.crossChainCore
-              );
-              if (routes.isManual(this.wormholeRoute)) {
-                const circleAttestationReceipt = await this.wormholeRoute.complete(signer2, receipt);
-                logger.log("Claim receipt: ", circleAttestationReceipt);
-                const destinationChainTxnId = signer2.claimedTransactionHashes();
-                return {
-                  originChainTxnId: originChainTxnId || "",
-                  destinationChainTxnId
-                };
-              } else {
-                return {
-                  originChainTxnId: originChainTxnId || "",
-                  destinationChainTxnId: ""
-                };
-              }
-            } catch (e) {
-              console.error("Failed to claim", e);
-              return {
-                originChainTxnId: originChainTxnId || "",
-                destinationChainTxnId: ""
-              };
-            }
+          if (receipt.state >= TransferState.Attested) {
+            logger.log("trackWithdraw: receipt attested", receipt);
+            return receipt;
           }
         }
       } catch (e) {
         console.error(
-          `Error tracking transfer (attempt ${retries + 1} / ${maxRetries}):`,
+          `Error tracking withdraw (attempt ${retries + 1} / ${maxRetries}):`,
           e
         );
         const delay = baseDelay * Math.pow(2, retries);
@@ -893,10 +1108,173 @@ var WormholeProvider = class {
         retries++;
       }
     }
-    return {
-      originChainTxnId: originChainTxnId || "",
-      destinationChainTxnId: ""
-    };
+    throw new Error("Failed to track withdraw to attested state");
+  }
+  /**
+   * Phase 3: Claims the withdraw on the destination chain.
+   *
+   * If the destination is Solana and `solanaConfig.serverClaimUrl` is configured
+   * in the dapp config, the SDK automatically POSTs the attested receipt to that
+   * URL — no wallet popup required. The dapp's server endpoint handles signing
+   * and submitting the claim transaction.
+   *
+   * Otherwise falls back to the wallet-based Signer (triggers wallet popup).
+   */
+  async claimWithdraw(input) {
+    const { claimChain, destinationAddress, receipt } = input;
+    const serverClaimUrl = this.crossChainCore._dappConfig?.solanaConfig?.serverClaimUrl;
+    if (claimChain === "Solana" && serverClaimUrl) {
+      logger.log("claimWithdraw: using server-side claim via", serverClaimUrl);
+      const response = await fetch(serverClaimUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          receipt: serializeReceipt(receipt),
+          destinationAddress,
+          claimChain
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `Server-side claim failed with status ${response.status}`
+        );
+      }
+      const result = await response.json();
+      return { destinationChainTxnId: result.destinationChainTxnId };
+    }
+    if (!this.wormholeRoute) {
+      throw new Error("Wormhole route not initialized");
+    }
+    if (!input.wallet) {
+      throw new Error(
+        "Wallet is required for claim when serverClaimUrl is not configured"
+      );
+    }
+    const claimSigner = new Signer(
+      this.getChainConfig(claimChain),
+      destinationAddress,
+      {},
+      input.wallet,
+      this.crossChainCore,
+      void 0,
+      input.onTransactionSigned,
+      false
+    );
+    if (routes3.isManual(this.wormholeRoute)) {
+      const circleAttestationReceipt = await this.wormholeRoute.complete(
+        claimSigner,
+        receipt
+      );
+      logger.log("claimWithdraw receipt:", circleAttestationReceipt);
+      const destinationChainTxnId = claimSigner.claimedTransactionHashes();
+      return { destinationChainTxnId };
+    } else {
+      throw new Error("Automatic route not supported for manual claim");
+    }
+  }
+  /**
+   * Withdraws USDC from Aptos to a destination chain.
+   * Orchestrates all three phases internally:
+   *   1. Initiate — user signs the Aptos burn transaction
+   *   2. Track — wait for Wormhole attestation
+   *   3. Claim — if serverClaimUrl is configured for Solana, delegates to
+   *      the server; otherwise uses the wallet-based signer.
+   *
+   * The optional `onPhaseChange` callback lets the dapp update its UI
+   * as the flow progresses.
+   */
+  async withdraw(input) {
+    const {
+      sourceChain,
+      wallet,
+      destinationAddress,
+      sponsorAccount,
+      onPhaseChange,
+      onTransactionSigned
+    } = input;
+    onPhaseChange?.("initiating");
+    const { originChainTxnId, receipt } = await this.initiateWithdraw({
+      wallet,
+      destinationAddress,
+      sponsorAccount,
+      onTransactionSigned
+    });
+    let currentPhase = "tracking";
+    try {
+      onPhaseChange?.("tracking");
+      const attestedReceipt = await this.trackWithdraw(receipt);
+      currentPhase = "claiming";
+      onPhaseChange?.("claiming");
+      const { destinationChainTxnId } = await this.claimWithdraw({
+        claimChain: sourceChain,
+        destinationAddress: destinationAddress.toString(),
+        receipt: attestedReceipt,
+        wallet,
+        onTransactionSigned
+      });
+      return { originChainTxnId, destinationChainTxnId };
+    } catch (error) {
+      throw new WithdrawError(
+        error?.message ?? "Withdraw failed after Aptos burn",
+        originChainTxnId,
+        currentPhase,
+        error
+      );
+    }
+  }
+  /**
+   * 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 sleep2(delay);
+          delay *= backoffMultiplier;
+        }
+      }
+    }
+    throw new Error(
+      `Claim failed after ${maxRetries + 1} attempts: ${lastError?.message}`
+    );
   }
   getChainConfig(chain) {
     const chainConfig = this.crossChainCore.CHAINS[chain];
@@ -905,16 +1283,124 @@ var WormholeProvider = class {
     }
     return chainConfig;
   }
-  getTokenInfo(sourceChain, destinationChain) {
-    const sourceToken = Wormhole.tokenId(
-      this.crossChainCore.TOKENS[sourceChain].tokenId.chain,
-      this.crossChainCore.TOKENS[sourceChain].tokenId.address
-    );
-    const destToken = Wormhole.tokenId(
-      this.crossChainCore.TOKENS[destinationChain].tokenId.chain,
-      this.crossChainCore.TOKENS[destinationChain].tokenId.address
+};
+
+// src/providers/wormhole/signers/SolanaLocalSigner.ts
+import {
+  Transaction as Transaction3
+} from "@solana/web3.js";
+var SolanaLocalSigner = class {
+  constructor(config) {
+    this._claimedTransactionHashes = [];
+    this.keypair = config.keypair;
+    this.connection = config.connection;
+    this.commitment = config.commitment ?? "finalized";
+    this.retryIntervalMs = config.retryIntervalMs ?? 5e3;
+    this.priorityFeeConfig = config.priorityFeeConfig;
+    this.verbose = config.verbose ?? false;
+    this._onTransactionSigned = config.onTransactionSigned;
+  }
+  chain() {
+    return "Solana";
+  }
+  address() {
+    return this.keypair.publicKey.toBase58();
+  }
+  /**
+   * Returns all transaction hashes from the most recent signAndSend call,
+   * joined by comma. If only one transaction was signed, returns a single hash string.
+   */
+  claimedTransactionHashes() {
+    return this._claimedTransactionHashes.join(",");
+  }
+  async signAndSend(txs) {
+    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);
+    }
+    return txHashes;
+  }
+  async signAndSendTransaction(request) {
+    const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash(this.commitment);
+    let unsignedTx = request.transaction ?? request;
+    const additionalSigners = request.transaction?.signers;
+    const MAX_UNWRAP_DEPTH = 10;
+    let unwrapDepth = 0;
+    while (unsignedTx && typeof unsignedTx === "object" && "transaction" in unsignedTx && !(unsignedTx instanceof Transaction3) && !("signatures" in unsignedTx && "message" in unsignedTx)) {
+      if (++unwrapDepth > MAX_UNWRAP_DEPTH) {
+        throw new Error(
+          "Transaction unwrapping exceeded maximum depth \u2014 possible circular nesting"
+        );
+      }
+      unsignedTx = unsignedTx.transaction;
+    }
+    const isVersioned = unsignedTx.message !== void 0 && unsignedTx.signatures !== void 0 && typeof unsignedTx.message.recentBlockhash !== "undefined";
+    if (isVersioned) {
+      unsignedTx.message.recentBlockhash = blockhash;
+      if (this.verbose || this.priorityFeeConfig) {
+        console.warn(
+          "SolanaLocalSigner: Versioned transaction detected \u2014 priority fees are not applied. Consider using legacy transactions if priority fees are required."
+        );
+      }
+      unsignedTx.sign([this.keypair]);
+      if (additionalSigners && additionalSigners.length > 0) {
+        unsignedTx.sign(additionalSigners);
+      }
+    } else if (unsignedTx instanceof Transaction3) {
+      unsignedTx.recentBlockhash = blockhash;
+      unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+      if (this.priorityFeeConfig) {
+        await addPriorityFeeInstructions(
+          this.connection,
+          unsignedTx,
+          this.priorityFeeConfig,
+          this.verbose
+        );
+      }
+      if (additionalSigners && additionalSigners.length > 0) {
+        unsignedTx.sign(this.keypair, ...additionalSigners);
+      } else {
+        unsignedTx.sign(this.keypair);
+      }
+    } else if (unsignedTx.recentBlockhash !== void 0 || unsignedTx.feePayer !== void 0) {
+      unsignedTx.recentBlockhash = blockhash;
+      unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+      if (this.priorityFeeConfig) {
+        await addPriorityFeeInstructions(
+          this.connection,
+          unsignedTx,
+          this.priorityFeeConfig,
+          this.verbose
+        );
+      }
+      if (additionalSigners && additionalSigners.length > 0) {
+        unsignedTx.sign(this.keypair, ...additionalSigners);
+      } else {
+        unsignedTx.sign(this.keypair);
+      }
+    } else {
+      throw new Error(
+        `Unsupported transaction type: ${unsignedTx?.constructor?.name}`
+      );
+    }
+    const serializedTx = unsignedTx.serialize();
+    const signature = await sendAndConfirmTransaction(
+      serializedTx,
+      blockhash,
+      lastValidBlockHeight,
+      {
+        connection: this.connection,
+        commitment: this.commitment,
+        retryIntervalMs: this.retryIntervalMs,
+        verbose: this.verbose
+      }
     );
-    return { sourceToken, destToken };
+    return signature;
   }
 };
 
@@ -988,8 +1474,8 @@ var testnetChains = {
     key: "Solana",
     context: "Solana" /* SOLANA */,
     displayName: "Solana",
-    explorerUrl: "https://explorer.solana.com/",
-    explorerName: "Solana Explorer",
+    explorerUrl: "https://solscan.io",
+    explorerName: "Solscan",
     chainId: 0,
     icon: "Solana",
     symbol: "SOL",
@@ -1112,8 +1598,8 @@ var mainnetChains = {
     key: "Solana",
     context: "Solana" /* SOLANA */,
     displayName: "Solana",
-    explorerUrl: "https://explorer.solana.com/",
-    explorerName: "Solana Explorer",
+    explorerUrl: "https://solscan.io",
+    explorerName: "Solscan",
     chainId: 0,
     icon: "Solana",
     symbol: "SOL",
@@ -1265,13 +1751,13 @@ var mainnetTokens = {
 
 // src/utils/getUsdcBalance.ts
 import { Aptos as Aptos3, AptosConfig as AptosConfig3, Network as Network2 } from "@aptos-labs/ts-sdk";
-import { Connection as Connection2, PublicKey } from "@solana/web3.js";
+import { Connection as Connection4, PublicKey } from "@solana/web3.js";
 import { ethers as ethers2, JsonRpcProvider } from "ethers";
 import { SuiClient } from "@mysten/sui/client";
 var getSolanaWalletUSDCBalance = async (walletAddress, aptosNetwork, rpc) => {
   const address = new PublicKey(walletAddress);
   const tokenAddress = aptosNetwork === Network2.MAINNET ? mainnetTokens["Solana"].tokenId.address : testnetTokens["Solana"].tokenId.address;
-  const connection = new Connection2(rpc);
+  const connection = new Connection4(rpc);
   const splToken = await connection.getTokenAccountsByOwner(address, {
     mint: new PublicKey(tokenAddress)
   });
@@ -1324,6 +1810,18 @@ var getSuiWalletUSDCBalance = async (walletAddress, aptosNetwork, rpc) => {
 
 // src/CrossChainCore.ts
 import { NetworkToChainId, NetworkToNodeAPI } from "@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,
@@ -1338,7 +1836,7 @@ var EthereumChainIdToMainnetChain = {
   43114: mainnetChains.Avalanche,
   137: mainnetChains.Polygon
 };
-var CrossChainCore = class {
+var CrossChainCore2 = class {
   constructor(args) {
     this._dappConfig = {
       aptosNetwork: Network3.TESTNET
@@ -1392,14 +1890,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}`);
@@ -1412,17 +1909,25 @@ import { Network as Network4 } from "@aptos-labs/ts-sdk";
 export {
   AptosLocalSigner,
   Context,
-  CrossChainCore,
+  CrossChainCore2 as CrossChainCore,
+  EVM_CHAIN_NAMES,
   EthereumChainIdToMainnetChain,
   EthereumChainIdToTestnetChain,
   Network4 as Network,
   NetworkToChainId,
   NetworkToNodeAPI,
+  SolanaLocalSigner,
+  TransferError,
+  WithdrawError,
   WormholeProvider,
+  createCCTPRoute,
+  deserializeReceipt,
   mainnetChains,
   mainnetTokens,
+  serializeReceipt,
   signAndSendTransaction,
   testnetChains,
-  testnetTokens
+  testnetTokens,
+  validateExpireTimestamp
 };
 //# sourceMappingURL=index.mjs.map