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

package/src/providers/wormhole/signers/SolanaLocalSigner.ts

@@ -0,0 +1,243 @@
+import {
+  Connection,
+  Keypair,
+  Transaction,
+  type Commitment,
+} from "@solana/web3.js";
+import {
+  Chain,
+  Network,
+  SignAndSendSigner,
+  TxHash,
+  UnsignedTransaction,
+} from "@wormhole-foundation/sdk";
+import {
+  addPriorityFeeInstructions,
+  PriorityFeeConfig,
+  sendAndConfirmTransaction,
+} from "./solanaUtils";
+
+export interface SolanaLocalSignerConfig {
+  /** The Solana keypair to sign transactions with */
+  keypair: Keypair;
+  /** The Solana RPC connection */
+  connection: Connection;
+  /** Transaction confirmation commitment level (default: "finalized") */
+  commitment?: Commitment;
+  /** Retry interval in ms when transaction is not confirmed (default: 5000) */
+  retryIntervalMs?: number;
+  /** Priority fee configuration for faster transaction landing */
+  priorityFeeConfig?: PriorityFeeConfig;
+  /** Enable verbose logging (default: false) */
+  verbose?: boolean;
+}
+
+/**
+ * Server-side Solana signer for programmatic transaction signing.
+ * Use this when you want to sign Solana transactions without user wallet interaction,
+ * such as for server-side claim operations.
+ *
+ * @example
+ * ```typescript
+ * import { SolanaLocalSigner } from "@aptos-labs/cross-chain-core";
+ * import { Connection, Keypair } from "@solana/web3.js";
+ * import bs58 from "bs58";
+ *
+ * const keypair = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_CLAIM_SIGNER_KEY));
+ * const connection = new Connection("https://api.mainnet-beta.solana.com");
+ *
+ * const signer = new SolanaLocalSigner({
+ *   keypair,
+ *   connection,
+ *   // Optional: configure priority fees for faster landing
+ *   priorityFeeConfig: {
+ *     percentile: 0.9,
+ *     min: 100_000,
+ *     max: 1_000_000,
+ *   },
+ * });
+ * await cctpRoute.complete(signer, receipt);
+ * ```
+ */
+export class SolanaLocalSigner<N extends Network, C extends Chain>
+  implements SignAndSendSigner<N, C>
+{
+  private keypair: Keypair;
+  private connection: Connection;
+  private commitment: Commitment;
+  private retryIntervalMs: number;
+  private priorityFeeConfig?: PriorityFeeConfig;
+  private verbose: boolean;
+  private _claimedTransactionHashes: string[] = [];
+
+  constructor(config: SolanaLocalSignerConfig) {
+    this.keypair = config.keypair;
+    this.connection = config.connection;
+    this.commitment = config.commitment ?? "finalized";
+    this.retryIntervalMs = config.retryIntervalMs ?? 5000;
+    this.priorityFeeConfig = config.priorityFeeConfig;
+    this.verbose = config.verbose ?? false;
+  }
+
+  chain(): C {
+    return "Solana" as C;
+  }
+
+  address(): string {
+    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(): string {
+    return this._claimedTransactionHashes.join(",");
+  }
+
+  async signAndSend(txs: UnsignedTransaction<N, C>[]): Promise<TxHash[]> {
+    const txHashes: TxHash[] = [];
+    this._claimedTransactionHashes = [];
+
+    for (const tx of txs) {
+      const txId = await this.signAndSendTransaction(tx);
+      txHashes.push(txId);
+      this._claimedTransactionHashes.push(txId);
+    }
+    return txHashes;
+  }
+
+  private async signAndSendTransaction(request: any): Promise<string> {
+    const { blockhash, lastValidBlockHeight } =
+      await this.connection.getLatestBlockhash(this.commitment);
+
+    // Wormhole SDK wraps transactions in SolanaUnsignedTransaction
+    // The actual transaction is in the .transaction property
+    // Sometimes it's nested: request.transaction.transaction
+    let unsignedTx = request.transaction ?? request;
+
+    // Capture additional signers before unwrapping.
+    // SolanaUnsignedTransaction nests them at request.transaction.signers
+    // (see SolanaSigner.ts for the client-side equivalent).
+    const additionalSigners = request.transaction?.signers;
+
+    // Unwrap nested transaction wrappers (Wormhole SDK's SolanaUnsignedTransaction)
+    const MAX_UNWRAP_DEPTH = 10;
+    let unwrapDepth = 0;
+    while (
+      unsignedTx &&
+      typeof unsignedTx === "object" &&
+      "transaction" in unsignedTx &&
+      !(unsignedTx instanceof Transaction) &&
+      !("signatures" in unsignedTx && "message" in unsignedTx)
+    ) {
+      if (++unwrapDepth > MAX_UNWRAP_DEPTH) {
+        throw new Error(
+          "Transaction unwrapping exceeded maximum depth — possible circular nesting",
+        );
+      }
+      unsignedTx = unsignedTx.transaction;
+    }
+
+    // Check if this is a versioned transaction using duck typing
+    // (VersionedTransaction has .message and .signatures properties)
+    const isVersioned =
+      unsignedTx.message !== undefined &&
+      unsignedTx.signatures !== undefined &&
+      typeof unsignedTx.message.recentBlockhash !== "undefined";
+
+    if (isVersioned) {
+      // For versioned transactions, we need to update the blockhash and sign
+      unsignedTx.message.recentBlockhash = blockhash;
+
+      // Note: Priority fees for versioned transactions would require rebuilding
+      // the message, which is more complex. For now, we skip priority fees for versioned txs.
+      if (this.verbose || this.priorityFeeConfig) {
+        console.warn(
+          "SolanaLocalSigner: Versioned transaction detected — priority fees are not applied. " +
+          "Consider using legacy transactions if priority fees are required.",
+        );
+      }
+      unsignedTx.sign([this.keypair]);
+
+      // Also sign with any additional signers from Wormhole SDK
+      if (additionalSigners && additionalSigners.length > 0) {
+        unsignedTx.sign(additionalSigners);
+      }
+    } else if (unsignedTx instanceof Transaction) {
+      // Legacy transaction handling
+      unsignedTx.recentBlockhash = blockhash;
+      unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+
+      // Add priority fee instructions if configured
+      if (this.priorityFeeConfig) {
+        await addPriorityFeeInstructions(
+          this.connection,
+          unsignedTx,
+          this.priorityFeeConfig,
+          this.verbose,
+        );
+      }
+
+      // Sign with the local keypair (and any additional signers in a single call).
+      // Transaction.sign() resets the signatures array to only the provided
+      // signers, so calling partialSign() afterwards for extra signers would
+      // throw "unknown signer". Passing everyone to sign() at once avoids this.
+      if (additionalSigners && additionalSigners.length > 0) {
+        unsignedTx.sign(this.keypair, ...additionalSigners);
+      } else {
+        unsignedTx.sign(this.keypair);
+      }
+    } else if (
+      unsignedTx.recentBlockhash !== undefined ||
+      unsignedTx.feePayer !== undefined
+    ) {
+      // Looks like a legacy transaction but instanceof check failed
+      // This can happen with different module instances
+      unsignedTx.recentBlockhash = blockhash;
+      unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+
+      // Add priority fee instructions if configured
+      if (this.priorityFeeConfig) {
+        await addPriorityFeeInstructions(
+          this.connection,
+          unsignedTx,
+          this.priorityFeeConfig,
+          this.verbose,
+        );
+      }
+
+      // Same rationale as the instanceof Transaction branch above:
+      // include all signers in a single sign() call to avoid "unknown signer".
+      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();
+
+    // Use shared utility for sending and confirming
+    const signature = await sendAndConfirmTransaction(
+      serializedTx,
+      blockhash,
+      lastValidBlockHeight,
+      {
+        connection: this.connection,
+        commitment: this.commitment,
+        retryIntervalMs: this.retryIntervalMs,
+        verbose: this.verbose,
+      },
+    );
+
+    return signature;
+  }
+}
+
+// Re-export PriorityFeeConfig for convenience
+export type { PriorityFeeConfig };

package/src/providers/wormhole/signers/SolanaSigner.ts

@@ -1,30 +1,34 @@
-// This function signs and sends the transaction while constantly checking for confirmation
-// and resending the transaction if it hasn't been confirmed after the specified interval
+/**
+ * Client-side Solana signer for wallet-based transaction signing.
+ * This function signs and sends the transaction while constantly checking for confirmation
+ * and resending the transaction if it hasn't been confirmed after the specified interval.
+ */
 
 import {
-  ComputeBudgetProgram,
   ConfirmOptions,
-  LAMPORTS_PER_SOL,
-  SimulatedTransactionResponse,
-  TransactionInstruction,
+  Transaction,
   VersionedTransaction,
 } from "@solana/web3.js";
 
-import { Transaction } from "@solana/web3.js";
-import { RpcResponseAndContext, SignatureResult } from "@solana/web3.js";
-import {
-  determinePriorityFee,
-  determinePriorityFeeTritonOne,
-  SolanaUnsignedTransaction,
-} from "@wormhole-foundation/sdk-solana";
-
 import { Connection } from "@solana/web3.js";
 import { Network } from "@wormhole-foundation/sdk";
+import { SolanaUnsignedTransaction } from "@wormhole-foundation/sdk-solana";
 import { AdapterWallet } from "@aptos-labs/wallet-adapter-core";
 import { CrossChainCore } from "../../../CrossChainCore";
 import { SolanaDerivedWallet } from "@aptos-labs/derived-wallet-solana";
-
-export type SolanaRpcProvider = "triton" | "helius" | "ankr" | "unknown";
+import {
+  addPriorityFeeInstructions,
+  sendAndConfirmTransaction,
+  PriorityFeeConfig,
+} from "./solanaUtils";
+
+// Re-export types for backwards compatibility
+export type { SolanaRpcProvider, PriorityFeeConfig } from "./solanaUtils";
+export {
+  sleep,
+  isEmptyObject,
+  determineRpcProvider,
+} from "./solanaUtils";
 
 // See https://docs.triton.one/chains/solana/sending-txs for more information
 export async function signAndSendTransaction(
@@ -34,7 +38,7 @@ export async function signAndSendTransaction(
   crossChainCore?: CrossChainCore,
 ) {
   if (!wallet || !(wallet instanceof SolanaDerivedWallet)) {
-    throw new Error("Invalid wallet type or missing Solana wallet").message;
+    throw new Error("Invalid wallet type or missing Solana wallet");
   }
 
   const commitment = options?.commitment ?? "finalized";
@@ -47,31 +51,22 @@ export async function signAndSendTransaction(
   const { blockhash, lastValidBlockHeight } =
     await connection.getLatestBlockhash(commitment);
 
-  /**
-   * TODO: Priority Fee is supported, but needs to come from dapp config
-   */
+  // Add priority fee instructions
   const unsignedTx = await setPriorityFeeInstructions(
     connection,
     blockhash,
     lastValidBlockHeight,
     request,
-    crossChainCore,
+    crossChainCore?._dappConfig?.solanaConfig?.priorityFeeConfig,
   );
 
-  let confirmTransactionPromise: Promise<
-    RpcResponseAndContext<SignatureResult>
-  > | null = null;
-  let confirmedTx: RpcResponseAndContext<SignatureResult> | null = null;
-  let txSendAttempts = 1;
-  let signature = "";
-
   if (!wallet.solanaWallet.signTransaction) {
-    throw new Error("Wallet does not support signing transactions").message;
+    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").message;
+  if (!tx) throw new Error("Failed to sign transaction");
 
   // Order matters. Phantom's Lighthouse security requires wallet to sign first,
   // then additional signers sign afterward
@@ -80,332 +75,45 @@ export async function signAndSendTransaction(
   }
 
   const serializedTx = tx.serialize();
-  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
-  };
-  signature = await connection.sendRawTransaction(serializedTx, sendOptions);
-  confirmTransactionPromise = connection.confirmTransaction(
+
+  // Use shared utility for sending and confirming
+  const signature = await sendAndConfirmTransaction(
+    serializedTx,
+    blockhash,
+    lastValidBlockHeight,
     {
-      signature,
-      blockhash,
-      lastValidBlockHeight,
+      connection,
+      commitment,
+      retryIntervalMs: 5000,
+      verbose: false,
     },
-    commitment,
   );
 
-  // This loop will break once the transaction has been confirmed or the block height is exceeded.
-  // An exception will be thrown if the block height is exceeded by the confirmTransactionPromise.
-  // The transaction will be resent if it hasn't been confirmed after the interval.
-  const txRetryInterval = 5000;
-  while (!confirmedTx) {
-    confirmedTx = await Promise.race([
-      confirmTransactionPromise,
-      new Promise<null>((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") {
-      try {
-        errorMessage = `Transaction failed: ${JSON.stringify(
-          confirmedTx.value.err,
-          (_key, value) =>
-            typeof value === "bigint" ? value.toString() : value, // Handle bigint props
-        )}`;
-      } catch (e: unknown) {
-        // Most likely a circular reference error, we can't stringify this error object.
-        // See for more details:
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#exceptions
-        errorMessage = `Transaction failed: Unknown error`;
-      }
-    }
-    throw new Error(`Transaction failed: ${errorMessage}`).message;
-  }
-
   return signature;
 }
 
+/**
+ * Prepares a transaction with priority fee instructions.
+ */
 export async function setPriorityFeeInstructions(
   connection: Connection,
   blockhash: string,
   lastValidBlockHeight: number,
   request: SolanaUnsignedTransaction<Network>,
-  crossChainCore?: CrossChainCore,
+  priorityFeeConfig?: PriorityFeeConfig,
 ): Promise<Transaction | VersionedTransaction> {
   const unsignedTx = request.transaction.transaction as Transaction;
 
-  const computeBudgetIxFilter = (ix: TransactionInstruction) =>
-    ix.programId.toString() !== "ComputeBudget111111111111111111111111111111";
-
   unsignedTx.recentBlockhash = blockhash;
   unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
 
-  // Remove existing compute budget instructions if they were added by the SDK
-  unsignedTx.instructions = unsignedTx.instructions.filter(
-    computeBudgetIxFilter,
-  );
-  unsignedTx.add(
-    ...(await createPriorityFeeInstructions(
-      connection,
-      unsignedTx,
-      crossChainCore,
-    )),
+  // Add priority fee instructions using shared utility
+  await addPriorityFeeInstructions(
+    connection,
+    unsignedTx,
+    priorityFeeConfig,
+    false,
   );
 
   return unsignedTx;
 }
-
-// This will throw if the simulation fails
-async function createPriorityFeeInstructions(
-  connection: Connection,
-  transaction: Transaction | VersionedTransaction,
-  crossChainCore?: CrossChainCore,
-) {
-  let unitsUsed = 200_000;
-  let simulationAttempts = 0;
-
-  simulationLoop: while (true) {
-    const response = await connection.simulateTransaction(
-      transaction as Transaction,
-    );
-
-    if (response.value.err) {
-      if (checkKnownSimulationError(response.value)) {
-        // Number of attempts will be at most 5 for known errors
-        if (simulationAttempts < 5) {
-          simulationAttempts++;
-          await sleep(1000);
-          continue simulationLoop;
-        }
-      } else if (simulationAttempts < 3) {
-        // Number of attempts will be at most 3 for unknown errors
-        simulationAttempts++;
-        await sleep(1000);
-        continue simulationLoop;
-      }
-
-      // Still failing after multiple attempts for both known and unknown errors
-      // We should throw in that case
-      throw new Error(
-        `Simulation failed: ${JSON.stringify(response.value.err)}\nLogs:\n${(
-          response.value.logs || []
-        ).join("\n  ")}`,
-      ).message;
-    } else {
-      // Simulation was successful
-      if (response.value.unitsConsumed) {
-        unitsUsed = response.value.unitsConsumed;
-      }
-      break;
-    }
-  }
-
-  const unitBudget = Math.floor(unitsUsed * 1.2); // Budget in 20% headroom
-
-  const instructions: TransactionInstruction[] = [];
-  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 = 100_000,
-    max = 100_000_000,
-  } = crossChainCore?._dappConfig?.solanaConfig?.priorityFeeConfig ?? {};
-
-  const calculateFee = async (
-    rpcProvider?: SolanaRpcProvider,
-  ): Promise<{ fee: number; methodUsed: "triton" | "default" | "minimum" }> => {
-    if (rpcProvider === "triton") {
-      // Triton has an experimental RPC method that accepts a percentile paramater
-      // and usually gives more accurate fee numbers.
-      try {
-        const fee = await determinePriorityFeeTritonOne(
-          connection,
-          transaction,
-          percentile,
-          percentileMultiple,
-          min,
-          max,
-        );
-
-        return {
-          fee,
-          methodUsed: "triton",
-        };
-      } catch (e) {
-        console.warn(`Failed to determine priority fee using Triton RPC:`, e);
-      }
-    }
-
-    try {
-      // By default, use generic Solana RPC method
-      const fee = await determinePriorityFee(
-        connection,
-        transaction,
-        percentile,
-        percentileMultiple,
-        min,
-        max,
-      );
-
-      return {
-        fee,
-        methodUsed: "default",
-      };
-    } 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;
-}
-
-// Checks response logs for known errors.
-// Returns when the first error is encountered.
-function checkKnownSimulationError(
-  response: SimulatedTransactionResponse,
-): boolean {
-  const errors = {} as any;
-
-  // This error occur when the blockhash included in a transaction is not deemed to be valid
-  // when a validator processes a transaction. We can retry the simulation to get a valid blockhash.
-  if (response.err === "BlockhashNotFound") {
-    errors["BlockhashNotFound"] =
-      "Blockhash not found during simulation. Trying again.";
-  }
-
-  // Check the response logs for any known errors
-  if (response.logs) {
-    for (const line of response.logs) {
-      // In some cases which aren't deterministic, like a slippage error, we can retry the
-      // simulation a few times to get a successful response.
-      if (line.includes("SlippageToleranceExceeded")) {
-        errors["SlippageToleranceExceeded"] =
-          "Slippage failure during simulation. Trying again.";
-      }
-
-      // In this case a require_gte expression was violated during a Swap instruction.
-      // We can retry the simulation to get a successful response.
-      if (line.includes("RequireGteViolated")) {
-        errors["RequireGteViolated"] =
-          "Swap instruction failure during simulation. Trying again.";
-      }
-    }
-  }
-
-  // No known simulation errors found
-  if (isEmptyObject(errors)) {
-    return false;
-  }
-
-  console.table(errors);
-  return true;
-}
-
-export async function sleep(timeout: number) {
-  return new Promise((resolve) => setTimeout(resolve, timeout));
-}
-
-/**
- * Checks whether an object is empty.
- *
- * isEmptyObject(null)
- * // => true
- *
- * isEmptyObject(undefined)
- * // => true
- *
- * isEmptyObject({})
- * // => true
- *
- * isEmptyObject({ 'a': 1 })
- * // => false
- */
-export const isEmptyObject = (value: object | null | undefined) => {
-  if (value === null || value === undefined) {
-    return true;
-  }
-
-  // Check all property keys for any own prop
-  for (const key in value) {
-    if (value.hasOwnProperty.call(value, key)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-function determineRpcProvider(endpoint: string): SolanaRpcProvider {
-  try {
-    const url = new URL(endpoint);
-    const hostname = url.hostname;
-    if (hostname === "rpcpool.com") {
-      return "triton";
-    } else if (hostname === "helius-rpc.com") {
-      return "helius";
-    } else if (hostname === "rpc.ankr.com") {
-      return "ankr";
-    } else {
-      return "unknown";
-    }
-  } catch (e) {
-    return "unknown";
-  }
-}