@aptos-labs/cross-chain-core 5.8.2 → 5.9.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,6 +33,92 @@ 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,
@@ -41,11 +126,11 @@ import {
 } from "@aptos-labs/ts-sdk";
 var AptosLocalSigner = class {
   constructor(chain, options, wallet, feePayerAccount, dappNetwork) {
+    this._claimedTransactionHashes = [];
     this._chain = chain;
     this._options = options;
     this._wallet = wallet;
     this._sponsorAccount = feePayerAccount;
-    this._claimedTransactionHashes = "";
     this._dappNetwork = dappNetwork;
   }
   chain() {
@@ -55,10 +140,11 @@ 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) {
       const txId = await signAndSendTransaction(
         tx,
@@ -67,7 +153,7 @@ var AptosLocalSigner = class {
         this._dappNetwork
       );
       txHashes.push(txId);
-      this._claimedTransactionHashes = txId;
+      this._claimedTransactionHashes.push(txId);
     }
     return txHashes;
   }
@@ -118,125 +204,131 @@ async function signAndSendTransaction(request, wallet, sponsorAccount, dappNetwo
 }
 
 // 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;
+  let confirmedTx = null;
+  let txSendAttempts = 1;
   while (!confirmedTx) {
     confirmedTx = await Promise.race([
       confirmTransactionPromise,
       new Promise(
-        (resolve) => setTimeout(() => {
-          resolve(null);
-        }, txRetryInterval)
+        (resolve) => setTimeout(() => resolve(null), retryIntervalMs)
       )
     ]);
-    if (confirmedTx) {
-      break;
+    if (confirmedTx) break;
+    if (verbose) {
+      console.log(
+        `Tx not confirmed after ${retryIntervalMs * txSendAttempts++}ms, resending`
+      );
     }
-    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 (verbose) {
+        console.error("Failed to resend transaction:", e);
+      }
     }
   }
   if (confirmedTx.value.err) {
-    let errorMessage = `Transaction failed: ${confirmedTx.value.err}`;
-    if (typeof confirmedTx.value.err === "object") {
-      try {
-        errorMessage = `Transaction failed: ${JSON.stringify(
-          confirmedTx.value.err,
-          (_key, value) => typeof value === "bigint" ? value.toString() : value
-          // Handle bigint props
-        )}`;
-      } catch (e) {
-        errorMessage = `Transaction failed: Unknown error`;
-      }
-    }
-    throw new Error(`Transaction failed: ${errorMessage}`).message;
+    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 +345,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 +353,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 +367,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,61 +402,106 @@ 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) {
+  } catch {
     return "unknown";
   }
 }
+async function sleep(timeout) {
+  return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+
+// src/providers/wormhole/signers/SolanaSigner.ts
+async function signAndSendTransaction2(request, wallet, options, crossChainCore) {
+  if (!wallet || !(wallet instanceof SolanaDerivedWallet)) {
+    throw new Error("Invalid wallet type or missing Solana wallet");
+  }
+  const commitment = options?.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) {
   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;
+    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
@@ -426,7 +523,7 @@ 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;
+    throw new Error("wallet.sendTransaction is undefined");
   }
   const payload = request.transaction;
   payload.functionArguments = payload.functionArguments.map((a) => {
@@ -526,13 +623,13 @@ async function signAndSendTransaction5(request, wallet) {
 // src/providers/wormhole/signers/Signer.ts
 var Signer = class {
   constructor(chain, address, options, wallet, crossChainCore, sponsorAccount) {
+    this._claimedTransactionHashes = [];
     this._chain = chain;
     this._address = address;
     this._options = options;
     this._wallet = wallet;
     this._crossChainCore = crossChainCore;
     this._sponsorAccount = sponsorAccount;
-    this._claimedTransactionHashes = "";
   }
   chain() {
     return this._chain.key;
@@ -541,10 +638,11 @@ 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) {
       const txId = await signAndSendTransaction6(
         this._chain,
@@ -555,7 +653,7 @@ var Signer = class {
         this._sponsorAccount
       );
       txHashes.push(txId);
-      this._claimedTransactionHashes = txId;
+      this._claimedTransactionHashes.push(txId);
     }
     return txHashes;
   }
@@ -600,6 +698,49 @@ 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/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) {
@@ -632,33 +773,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,12 +803,12 @@ 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);
@@ -727,7 +850,7 @@ 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 };
@@ -756,7 +879,7 @@ var WormholeProvider = class {
                 // the fee payer account
                 this.crossChainCore._dappConfig?.aptosNetwork
               );
-              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();
@@ -806,15 +929,14 @@ var WormholeProvider = class {
     });
     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);
-    }
+  // --- 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 } = input;
     if (!this._wormholeContext) {
       throw new Error("Wormhole context not initialized");
     }
@@ -823,69 +945,48 @@ 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
     );
-    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 +994,108 @@ 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 { sourceChain, destinationAddress, receipt } = input;
+    const serverClaimUrl = this.crossChainCore._dappConfig?.solanaConfig?.serverClaimUrl;
+    if (sourceChain === "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,
+          sourceChain
+        })
+      });
+      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(sourceChain),
+      destinationAddress,
+      {},
+      input.wallet,
+      this.crossChainCore
+    );
+    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 } = input;
+    onPhaseChange?.("initiating");
+    const { originChainTxnId, receipt } = await this.initiateWithdraw({
+      wallet,
+      destinationAddress,
+      sponsorAccount
+    });
+    let currentPhase = "tracking";
+    try {
+      onPhaseChange?.("tracking");
+      const attestedReceipt = await this.trackWithdraw(receipt);
+      currentPhase = "claiming";
+      onPhaseChange?.("claiming");
+      const { destinationChainTxnId } = await this.claimWithdraw({
+        sourceChain,
+        destinationAddress: destinationAddress.toString(),
+        receipt: attestedReceipt,
+        wallet
+      });
+      return { originChainTxnId, destinationChainTxnId };
+    } catch (error) {
+      throw new WithdrawError(
+        error?.message ?? "Withdraw failed after Aptos burn",
+        originChainTxnId,
+        currentPhase,
+        error
+      );
+    }
   }
   getChainConfig(chain) {
     const chainConfig = this.crossChainCore.CHAINS[chain];
@@ -905,16 +1104,121 @@ 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;
+  }
+  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) {
+      const txId = await this.signAndSendTransaction(tx);
+      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 +1292,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 +1416,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 +1569,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)
   });
@@ -1418,9 +1722,14 @@ export {
   Network4 as Network,
   NetworkToChainId,
   NetworkToNodeAPI,
+  SolanaLocalSigner,
+  WithdrawError,
   WormholeProvider,
+  createCCTPRoute,
+  deserializeReceipt,
   mainnetChains,
   mainnetTokens,
+  serializeReceipt,
   signAndSendTransaction,
   testnetChains,
   testnetTokens