manual route axelar transceiver

Author: kev1n-peters

evm/ts/package.json

@@ -44,7 +44,7 @@
     "test": "jest --config ./jest.config.ts"
   },
   "dependencies": {
-    "@axelar-network/axelarjs-sdk": "^0.17.4",
+    "@axelar-network/axelarjs-sdk": "^0.17.6-alpha.2",
     "@wormhole-foundation/sdk-definitions-ntt": "1.0.0",
     "ethers": "^6.5.1"
   },

evm/ts/src/axelar.ts

@@ -1,27 +1,29 @@
 import { Chain, Network } from "@wormhole-foundation/sdk-base";
 import {
-  AxelarQueryAPI,
+  AxelarGMPRecoveryAPI,
   Environment,
-  EvmChain,
+  GMPStatusResponse,
 } from "@axelar-network/axelarjs-sdk";
 
-export const axelarChains: Partial<Record<Chain, EvmChain>> = {
-  Sepolia: EvmChain.SEPOLIA,
-  // Monad: EvmChain.MONAD,
-  Ethereum: EvmChain.ETHEREUM,
+// See: https://github.com/axelarnetwork/axelarjs-sdk/blob/main/src/constants/EvmChain.ts
+export const axelarChains: Partial<Record<Chain, string>> = {
+  Ethereum: "ethereum",
+  Monad: "monad",
+  Sepolia: "ethereum-sepolia",
   // add more as needed
 };
 
 export async function getAxelarGasFee(
   network: Network,
   sourceChain: Chain,
   destinationChain: Chain,
-  gasLimit: bigint
+  gasLimit: bigint,
+  timeoutMs = 10000
 ): Promise<bigint> {
-  const api = new AxelarQueryAPI({
-    environment:
-      network === "Mainnet" ? Environment.MAINNET : Environment.TESTNET,
-  });
+  const baseUrl =
+    network === "Mainnet"
+      ? "https://api.axelarscan.io/gmp/estimateGasFee"
+      : "https://testnet.api.axelarscan.io/gmp/estimateGasFee";
 
   const axelarSourceChain = axelarChains[sourceChain];
   if (!axelarSourceChain) {
@@ -33,15 +35,54 @@ export async function getAxelarGasFee(
     throw new Error(`Unsupported destination chain: ${destinationChain}`);
   }
 
-  const response = await api.estimateGasFee(
-    axelarSourceChain,
-    axelarDestinationChain,
-    gasLimit
-  );
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        sourceChain: axelarSourceChain,
+        destinationChain: axelarDestinationChain,
+        sourceTokenAddress: "0x0000000000000000000000000000000000000000",
+        gasMultiplier: "auto",
+        gasLimit: gasLimit.toString(),
+      }),
+      signal: controller.signal,
+    });
 
-  if (typeof response !== "string") {
-    throw new Error(`Unexpected response type: ${typeof response}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to estimate gas fee: ${response.status} ${errorText}`
+      );
+    }
+
+    const result = await response.json();
+
+    return BigInt(result);
+  } finally {
+    clearTimeout(timeoutId);
   }
+}
+
+export async function getAxelarTransactionStatus(
+  network: Network,
+  txHash: string
+): Promise<GMPStatusResponse> {
+  const api = new AxelarGMPRecoveryAPI({
+    environment:
+      network === "Mainnet" ? Environment.MAINNET : Environment.TESTNET,
+  });
+  const status = await api.queryTransactionStatus(txHash);
+  return status;
+}
 
-  return BigInt(response);
+export function getAxelarExplorerUrl(network: Network, txHash: string): string {
+  return network === "Mainnet"
+    ? `https://axelarscan.io/gmp/${txHash}`
+    : `https://testnet.axelarscan.io/gmp/${txHash}`;
 }

evm/ts/src/index.ts

@@ -9,12 +9,15 @@ import "@wormhole-foundation/sdk-definitions-ntt";
 registerProtocol(_platform, "Ntt", EvmNtt);
 registerProtocol(_platform, "NttWithExecutor", EvmNttWithExecutor);
 registerProtocol(_platform, "MultiTokenNtt", EvmMultiTokenNtt);
-registerProtocol(_platform, "MultiTokenNttWithExecutor", EvmMultiTokenNttWithExecutor);
+registerProtocol(
+  _platform,
+  "MultiTokenNttWithExecutor",
+  EvmMultiTokenNttWithExecutor
+);
 
 export * as ethers_contracts from "./ethers-contracts/index.js";
 export * from "./ntt.js";
 export * from "./nttWithExecutor.js";
 export * from "./multiTokenNtt.js";
 export * from "./multiTokenNttWithExecutor.js";
-export * from "./trimmedAmount.js";
-   
+export * from "./axelar.js";

evm/ts/src/multiTokenNtt.ts

@@ -29,9 +29,12 @@ import {
 import "@wormhole-foundation/sdk-evm-core";
 
 import {
+  decodeTrimmedAmount,
+  EncodedTrimmedAmount,
   MultiTokenNtt,
   Ntt,
   TrimmedAmount,
+  untrim,
 } from "@wormhole-foundation/sdk-definitions-ntt";
 import { Contract, ethers, Interface, type Provider } from "ethers";
 import {
@@ -40,11 +43,6 @@ import {
   MultiTokenNttBindings,
   MultiTokenNttManagerBindings,
 } from "./multiTokenNttBindings.js";
-import {
-  decodeTrimmedAmount,
-  EncodedTrimmedAmount,
-  untrim,
-} from "./trimmedAmount.js";
 import { getAxelarGasFee } from "./axelar.js";
 import { encoding } from "@wormhole-foundation/sdk-base";
 
@@ -213,6 +211,17 @@ export class EvmMultiTokenNtt<N extends Network, C extends EvmChains>
     );
   }
 
+  async transceiverAttestedToMessage(
+    fromChain: Chain,
+    transceiverMessage: MultiTokenNtt.Message,
+    index: number
+  ): Promise<boolean> {
+    return await this.gmpManager.transceiverAttestedToMessage(
+      MultiTokenNtt.messageDigest(fromChain, transceiverMessage),
+      index
+    );
+  }
+
   private async getTransceiverType(
     transceiverAddress: string
   ): Promise<string> {
@@ -254,12 +263,12 @@ export class EvmMultiTokenNtt<N extends Network, C extends EvmChains>
                 dstChain,
                 gasLimit
               );
+              console.log(`Fetched axelar gas fee: ${gasFee} wei`);
             } catch (e) {
               // If we fail to fetch the gas fee, then use 0 as a fallback.
               // The Axelar relay should fail and the track() method will
-              // surface a RelayFailedError that a UI can use to inform the user.
-              // We don't want to block the transfer entirely just because
-              // of a failure to fetch the gas fee.
+              // surface a RelayFailedError. We don't want to fail the entire
+              // transfer just because we couldn't fetch the gas fee quote.
               gasFee = 100000000000000n; // 0.0001 ETH
               console.error(`Failed to fetch axelar gas fee: ${e}`);
             }

evm/ts/src/ntt.ts

@@ -30,9 +30,12 @@ import {
 import "@wormhole-foundation/sdk-evm-core";
 
 import {
+  decodeTrimmedAmount,
+  EncodedTrimmedAmount,
   EvmNttTransceiver,
   Ntt,
   NttTransceiver,
+  untrim,
   WormholeNttTransceiver,
 } from "@wormhole-foundation/sdk-definitions-ntt";
 import { Contract, type Provider, type TransactionRequest } from "ethers";
@@ -42,12 +45,6 @@ import {
   NttTransceiverBindings,
   loadAbiVersion,
 } from "./bindings.js";
-import {
-  decodeTrimmedAmount,
-  EncodedTrimmedAmount,
-  TrimmedAmount,
-  untrim,
-} from "./trimmedAmount.js";
 
 export class EvmNttWormholeTranceiver<N extends Network, C extends EvmChains>
   implements
@@ -438,7 +435,9 @@ export class EvmNtt<N extends Network, C extends EvmChains>
       return abiVersion;
     } catch (e) {
       console.error(
-        `Failed to get NTT_MANAGER_VERSION from contract ${contracts.ntt?.manager} on ${(await provider.getNetwork()).name}`
+        `Failed to get NTT_MANAGER_VERSION from contract ${
+          contracts.ntt?.manager
+        } on ${(await provider.getNetwork()).name}`
       );
       throw e;
     }
@@ -590,7 +589,7 @@ export class EvmNtt<N extends Network, C extends EvmChains>
     const encoded: EncodedTrimmedAmount = (
       await this.manager.getOutboundLimitParams()
     ).limit;
-    const trimmedAmount: TrimmedAmount = decodeTrimmedAmount(encoded);
+    const trimmedAmount = decodeTrimmedAmount(encoded);
     const tokenDecimals = await this.getTokenDecimals();
 
     return untrim(trimmedAmount, tokenDecimals);
@@ -609,7 +608,7 @@ export class EvmNtt<N extends Network, C extends EvmChains>
     const encoded: EncodedTrimmedAmount = (
       await this.manager.getInboundLimitParams(toChainId(fromChain))
     ).limit;
-    const trimmedAmount: TrimmedAmount = decodeTrimmedAmount(encoded);
+    const trimmedAmount = decodeTrimmedAmount(encoded);
     const tokenDecimals = await this.getTokenDecimals();
 
     return untrim(trimmedAmount, tokenDecimals);