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

package/src/providers/wormhole/wormhole.ts

@@ -15,10 +15,12 @@ import {
   Chain,
   CrossChainProvider,
   CrossChainCore,
+  EVM_CHAIN_NAMES,
 } from "../../CrossChainCore";
 import { logger } from "../../utils/logger";
 import { serializeReceipt } from "../../utils/receiptSerialization";
 import { AptosLocalSigner } from "./signers/AptosLocalSigner";
+import { isAccount } from "./signers/AptosSigner";
 import { Signer } from "./signers/Signer";
 import { ChainConfig } from "../../config";
 import { createCCTPRoute } from "./utils";
@@ -38,7 +40,10 @@ import {
   WormholeInitiateWithdrawResponse,
   WormholeClaimWithdrawRequest,
   WormholeClaimWithdrawResponse,
+  RetryWithdrawClaimRequest,
+  RetryWithdrawClaimResponse,
   WithdrawError,
+  TransferError,
 } from "./types";
 import { SolanaDerivedWallet } from "@aptos-labs/derived-wallet-solana";
 import { EIP1193DerivedWallet } from "@aptos-labs/derived-wallet-ethereum";
@@ -80,16 +85,31 @@ export class WormholeProvider implements CrossChainProvider<
     const isMainnet = dappNetwork === Network.MAINNET;
     const platforms: PlatformLoader<any>[] = [aptos, solana, evm, sui];
 
-    // Get custom RPC endpoints from config
+    // RPC resolution order per chain:
+    //  1. User-provided config (solanaConfig / suiConfig / evmConfig)
+    //  2. Built-in defaultRpc from CHAINS config
+    const dappConfig = this.crossChainCore._dappConfig;
+    const chains = this.crossChainCore.CHAINS;
+
     const solanaRpc =
-      this.crossChainCore._dappConfig?.solanaConfig?.rpc ??
-      this.crossChainCore.CHAINS["Solana"]?.defaultRpc;
+      dappConfig?.solanaConfig?.rpc ?? chains["Solana"]?.defaultRpc;
+
+    const suiRpc = dappConfig?.suiConfig?.rpc ?? chains["Sui"]?.defaultRpc;
+
+    const evmChainsConfig: Record<string, { rpc: string }> = {};
+    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;
@@ -162,7 +182,8 @@ export class WormholeProvider implements CrossChainProvider<
   async submitCCTPTransfer(
     input: WormholeSubmitTransferRequest,
   ): Promise<WormholeStartTransferResponse> {
-    const { sourceChain, wallet, destinationAddress } = input;
+    const { sourceChain, wallet, destinationAddress, onTransactionSigned } =
+      input;
 
     if (!this._wormholeContext) {
       await this.setWormholeContext(sourceChain);
@@ -201,6 +222,8 @@ export class WormholeProvider implements CrossChainProvider<
       {},
       wallet,
       this.crossChainCore,
+      undefined,
+      onTransactionSigned,
     );
 
     logger.log("signer", signer);
@@ -225,10 +248,18 @@ export class WormholeProvider implements CrossChainProvider<
   async claimCCTPTransfer(
     input: WormholeClaimTransferRequest,
   ): Promise<{ destinationChainTxnId: string }> {
-    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());
 
@@ -248,7 +279,8 @@ export class WormholeProvider implements CrossChainProvider<
                 {},
                 mainSigner, // the account that signs the "claim" transaction
                 sponsorAccount, // the fee payer account
-                this.crossChainCore._dappConfig?.aptosNetwork,
+                this.crossChainCore,
+                onTransactionSigned,
               );
 
               if (routes.isManual(this.wormholeRoute)) {
@@ -304,12 +336,21 @@ export class WormholeProvider implements CrossChainProvider<
     // Submit transfer transaction from origin chain
     let { originChainTxnId, receipt } = await this.submitCCTPTransfer(input);
     // Claim transfer transaction on destination chain
-    const { destinationChainTxnId } = await this.claimCCTPTransfer({
-      receipt,
-      mainSigner: input.mainSigner,
-      sponsorAccount: input.sponsorAccount,
-    });
-    return { originChainTxnId, destinationChainTxnId };
+    try {
+      const { destinationChainTxnId } = await this.claimCCTPTransfer({
+        receipt,
+        mainSigner: input.mainSigner,
+        sponsorAccount: input.sponsorAccount,
+        onTransactionSigned: input.onTransactionSigned,
+      });
+      return { originChainTxnId, destinationChainTxnId };
+    } catch (error: any) {
+      throw new TransferError(
+        error?.message ?? "Transfer claim failed after source-chain burn",
+        originChainTxnId,
+        error,
+      );
+    }
   }
 
   // --- Split withdraw flow: initiateWithdraw + trackWithdraw + claimWithdraw ---
@@ -322,7 +363,8 @@ export class WormholeProvider implements CrossChainProvider<
   async initiateWithdraw(
     input: WormholeInitiateWithdrawRequest,
   ): Promise<WormholeInitiateWithdrawResponse> {
-    const { wallet, destinationAddress, sponsorAccount } = input;
+    const { wallet, destinationAddress, sponsorAccount, onTransactionSigned } =
+      input;
 
     if (!this._wormholeContext) {
       throw new Error("Wormhole context not initialized");
@@ -333,13 +375,12 @@ export class WormholeProvider implements CrossChainProvider<
 
     const signer = new Signer(
       this.getChainConfig("Aptos"),
-      (
-        await wallet.features["aptos:account"].account()
-      ).address.toString(),
+      (await wallet.features["aptos:account"].account()).address.toString(),
       {},
       wallet,
       this.crossChainCore,
       sponsorAccount,
+      onTransactionSigned,
     );
 
     const wormholeDestAddress = Wormhole.chainAddress(
@@ -367,9 +408,7 @@ export class WormholeProvider implements CrossChainProvider<
    * 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: routes.Receipt,
-  ): Promise<routes.Receipt> {
+  async trackWithdraw(receipt: routes.Receipt): Promise<routes.Receipt> {
     if (!this.wormholeRoute) {
       throw new Error("Wormhole route not initialized");
     }
@@ -412,13 +451,13 @@ export class WormholeProvider implements CrossChainProvider<
   async claimWithdraw(
     input: WormholeClaimWithdrawRequest,
   ): Promise<WormholeClaimWithdrawResponse> {
-    const { sourceChain, destinationAddress, receipt } = input;
+    const { claimChain, destinationAddress, receipt } = input;
 
     // Server-side claim path: Solana destination with configured serverClaimUrl
     const serverClaimUrl =
       this.crossChainCore._dappConfig?.solanaConfig?.serverClaimUrl;
 
-    if (sourceChain === "Solana" && serverClaimUrl) {
+    if (claimChain === "Solana" && serverClaimUrl) {
       logger.log("claimWithdraw: using server-side claim via", serverClaimUrl);
 
       const response = await fetch(serverClaimUrl, {
@@ -427,7 +466,7 @@ export class WormholeProvider implements CrossChainProvider<
         body: JSON.stringify({
           receipt: serializeReceipt(receipt),
           destinationAddress,
-          sourceChain,
+          claimChain,
         }),
       });
 
@@ -455,11 +494,14 @@ export class WormholeProvider implements CrossChainProvider<
     }
 
     const claimSigner = new Signer(
-      this.getChainConfig(sourceChain),
+      this.getChainConfig(claimChain),
       destinationAddress,
       {},
       input.wallet,
       this.crossChainCore,
+      undefined,
+      input.onTransactionSigned,
+      false,
     );
 
     if (routes.isManual(this.wormholeRoute)) {
@@ -489,7 +531,14 @@ export class WormholeProvider implements CrossChainProvider<
   async withdraw(
     input: WormholeWithdrawRequest,
   ): Promise<WormholeWithdrawResponse> {
-    const { sourceChain, wallet, destinationAddress, sponsorAccount, onPhaseChange } = input;
+    const {
+      sourceChain,
+      wallet,
+      destinationAddress,
+      sponsorAccount,
+      onPhaseChange,
+      onTransactionSigned,
+    } = input;
 
     // Phase 1: Initiate — user signs Aptos burn
     onPhaseChange?.("initiating");
@@ -497,6 +546,7 @@ export class WormholeProvider implements CrossChainProvider<
       wallet,
       destinationAddress,
       sponsorAccount,
+      onTransactionSigned,
     });
 
     // Phases 2 & 3 are wrapped so that, if they fail, the caller still
@@ -511,10 +561,11 @@ export class WormholeProvider implements CrossChainProvider<
       currentPhase = "claiming";
       onPhaseChange?.("claiming");
       const { destinationChainTxnId } = await this.claimWithdraw({
-        sourceChain,
+        claimChain: sourceChain,
         destinationAddress: destinationAddress.toString(),
         receipt: attestedReceipt,
         wallet,
+        onTransactionSigned,
       });
 
       return { originChainTxnId, destinationChainTxnId };
@@ -528,6 +579,65 @@ export class WormholeProvider implements CrossChainProvider<
     }
   }
 
+  /**
+   * 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: RetryWithdrawClaimRequest,
+  ): Promise<RetryWithdrawClaimResponse> {
+    const {
+      maxRetries = 5,
+      initialDelayMs = 2000,
+      backoffMultiplier = 2,
+      ...claimInput
+    } = input;
+
+    let lastError: Error | undefined;
+    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 as Error;
+        logger.log(
+          `retryWithdrawClaim: attempt ${attempt + 1}/${maxRetries + 1} failed: ${lastError.message}`,
+        );
+        if (attempt < maxRetries) {
+          await sleep(delay);
+          delay *= backoffMultiplier;
+        }
+      }
+    }
+
+    throw new Error(
+      `Claim failed after ${maxRetries + 1} attempts: ${lastError?.message}`,
+    );
+  }
+
   getChainConfig(chain: Chain): ChainConfig {
     const chainConfig =
       this.crossChainCore.CHAINS[

package/src/version.ts

@@ -1 +1 @@
-export const CROSS_CHAIN_CORE_VERSION = "5.9.0";
+export const CROSS_CHAIN_CORE_VERSION = "6.0.0";