sdk: evm - support gas token transfers (wormhole-foundation#601)

* sdk: evm - support gas token transfers

The NTT manager doesn't support gas token transfers directly,
so we have to wrap it first.

* remove unused imports

Author: kev1n-peters

evm/ts/src/ntt.ts

@@ -472,6 +472,19 @@ export class EvmNtt<N extends Network, C extends EvmChains>
       options
     );
 
+    if (options.wrapNative) {
+      // TODO: the contract should handle this for us
+      const wrappedNative = new Contract(this.tokenAddress, [
+        "function deposit() public payable",
+      ]);
+
+      const txReq = await wrappedNative
+        .getFunction("deposit")
+        .populateTransaction({ value: amount });
+
+      yield this.createUnsignedTx(addFrom(txReq, senderAddress), "Ntt.Deposit");
+    }
+
     //TODO check for ERC-2612 (permit) support on token?
     const tokenContract = EvmPlatform.getTokenImplementation(
       this.provider,
@@ -487,6 +500,7 @@ export class EvmNtt<N extends Network, C extends EvmChains>
         this.managerAddress,
         amount
       );
+
       yield this.createUnsignedTx(addFrom(txReq, senderAddress), "Ntt.Approve");
     }
 

sdk/definitions/src/ntt.ts

@@ -58,6 +58,8 @@ export namespace Ntt {
     automatic?: boolean;
     /** How much native gas on the destination to send along with the transfer */
     gasDropoff?: bigint;
+    /** Whether or not the token needs to be wrapped, only relevant for gas token transfers */
+    wrapNative?: boolean;
   };
 
   // TODO: what are the set of attestation types for Ntt?
@@ -154,7 +156,7 @@ export namespace Ntt {
  * Ntt is the interface for the Ntt
  *
  * The Ntt is responsible for managing the coordination between the token contract and
- * the transceiver(s). It is also responsible for managing the capacity of inbound or outbount transfers.
+ * the transceiver(s). It is also responsible for managing the capacity of inbound or outbound transfers.
  *
  * @typeparam N the network
  * @typeparam C the chain

sdk/route/src/automatic.ts

@@ -19,6 +19,7 @@ import {
   finality,
   isAttested,
   isDestinationQueued,
+  isNative,
   isRedeemed,
   isSourceFinalized,
   isSourceInitiated,
@@ -98,13 +99,14 @@ export class NttAutomaticRoute<N extends Network>
   }
 
   async isAvailable(request: routes.RouteTransferRequest<N>): Promise<boolean> {
-    const nttContracts = NttRoute.resolveNttContracts(
+    const { srcContracts } = NttRoute.resolveNttContracts(
       this.staticConfig,
-      request.source.id
+      request.source.id,
+      request.destination.id
     );
 
     const ntt = await request.fromChain.getProtocol("Ntt", {
-      ntt: nttContracts,
+      ntt: srcContracts,
     });
 
     return ntt.isRelayingAvailable(request.toChain.chain);
@@ -121,29 +123,32 @@ export class NttAutomaticRoute<N extends Network>
       request.toChain.config.nativeTokenDecimals
     );
 
+    const wrapNative = isNative(request.source.id.address);
+
     const parsedAmount = amount.parse(params.amount, request.source.decimals);
     // The trimmedAmount may differ from the parsedAmount if the parsedAmount includes dust
     const trimmedAmount = NttRoute.trimAmount(
       parsedAmount,
       request.destination.decimals
     );
 
+    const { srcContracts, dstContracts } = NttRoute.resolveNttContracts(
+      this.staticConfig,
+      request.source.id,
+      request.destination.id
+    );
+
     const validatedParams: Vp = {
       amount: params.amount,
       normalizedParams: {
         amount: trimmedAmount,
-        sourceContracts: NttRoute.resolveNttContracts(
-          this.staticConfig,
-          request.source.id
-        ),
-        destinationContracts: NttRoute.resolveNttContracts(
-          this.staticConfig,
-          request.destination.id
-        ),
+        sourceContracts: srcContracts,
+        destinationContracts: dstContracts,
         options: {
           queue: false,
           automatic: true,
           gasDropoff: amount.units(gasDropoff),
+          wrapNative,
         },
       },
       options,

sdk/route/src/manual.ts

@@ -23,6 +23,7 @@ import {
   routes,
   signSendWait,
   finality,
+  isNative,
 } from "@wormhole-foundation/sdk-connect";
 import "@wormhole-foundation/sdk-definitions-ntt";
 import { NttRoute } from "./types.js";
@@ -116,22 +117,25 @@ export class NttManualRoute<N extends Network>
       )
     );
 
+    const wrapNative = isNative(request.source.id.address);
+
+    const { srcContracts, dstContracts } = NttRoute.resolveNttContracts(
+      this.staticConfig,
+      request.source.id,
+      request.destination.id
+    );
+
     const validatedParams: Vp = {
       amount: params.amount,
       normalizedParams: {
         amount: trimmedAmount,
-        sourceContracts: NttRoute.resolveNttContracts(
-          this.staticConfig,
-          request.source.id
-        ),
-        destinationContracts: NttRoute.resolveNttContracts(
-          this.staticConfig,
-          request.destination.id
-        ),
+        sourceContracts: srcContracts,
+        destinationContracts: dstContracts,
         options: {
           queue: false,
           automatic: false,
           gasDropoff,
+          wrapNative,
         },
       },
       options,

sdk/route/src/types.ts

@@ -10,6 +10,8 @@ import {
   TransferReceipt as _TransferReceipt,
   amount,
   canonicalAddress,
+  isNative,
+  nativeTokenId,
   routes,
 } from "@wormhole-foundation/sdk-connect";
 import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt";
@@ -31,6 +33,7 @@ export namespace NttRoute {
     manager: string;
     transceiver: TransceiverConfig[];
     quoter?: string;
+    isWrappedGasToken?: boolean;
   };
 
   export type Config = {
@@ -107,15 +110,22 @@ export namespace NttRoute {
     config: Config,
     fromChain: ChainContext<Network>
   ): TokenId[] {
-    const srcTokens = Object.entries(config.tokens)
-      .map(([, configs]) => {
+    const srcTokens = Object.entries(config.tokens).reduce<TokenId[]>(
+      (acc, [, configs]) => {
         const tokenConf = configs.find(
           (config) => config.chain === fromChain.chain
         );
-        if (!tokenConf) return null;
-        return Wormhole.tokenId(fromChain.chain, tokenConf!.token);
-      })
-      .filter((x) => !!x) as TokenId[];
+        if (tokenConf) {
+          acc.push(Wormhole.tokenId(fromChain.chain, tokenConf.token));
+
+          if (tokenConf.isWrappedGasToken) {
+            acc.push(nativeTokenId(fromChain.chain));
+          }
+        }
+        return acc;
+      },
+      []
+    );
 
     // TODO: dedupe?  //return routes.uniqueTokens(srcTokens);
     return srcTokens;
@@ -132,8 +142,9 @@ export namespace NttRoute {
         const match = configs.find(
           (config) =>
             config.chain === fromChain.chain &&
-            config.token.toLowerCase() ===
-              canonicalAddress(sourceToken).toLowerCase()
+            (config.token.toLowerCase() ===
+              canonicalAddress(sourceToken).toLowerCase() ||
+              (isNative(sourceToken.address) && config.isWrappedGasToken))
         );
         if (!match) return;
 
@@ -147,28 +158,56 @@ export namespace NttRoute {
 
   export function resolveNttContracts(
     config: Config,
-    token: TokenId
-  ): Ntt.Contracts {
+    srcToken: TokenId,
+    dstToken: TokenId
+  ): { srcContracts: Ntt.Contracts; dstContracts: Ntt.Contracts } {
     const cfg = Object.values(config.tokens);
-    const address = canonicalAddress(token);
+    const srcAddress = canonicalAddress(srcToken);
+    const dstAddress = canonicalAddress(dstToken);
+
     for (const tokens of cfg) {
-      const found = tokens.find(
+      const srcFound = tokens.find(
         (tc) =>
-          tc.token.toLowerCase() === address.toLowerCase() &&
-          tc.chain === token.chain
+          tc.chain === srcToken.chain &&
+          (tc.token.toLowerCase() === srcAddress.toLowerCase() ||
+            (isNative(srcToken.address) && tc.isWrappedGasToken))
       );
-      if (found)
-        return {
-          token: found.token,
-          manager: found.manager,
-          transceiver: {
-            wormhole: found.transceiver.find((v) => v.type === "wormhole")!
-              .address,
-          },
-          quoter: found.quoter,
-        };
+
+      if (srcFound) {
+        const dstFound = tokens.find(
+          (tc) =>
+            tc.chain === dstToken.chain &&
+            (tc.token.toLowerCase() === dstAddress.toLowerCase() ||
+              (isNative(dstToken.address) && tc.isWrappedGasToken))
+        );
+
+        if (dstFound) {
+          return {
+            srcContracts: {
+              token: srcFound.token,
+              manager: srcFound.manager,
+              transceiver: {
+                wormhole: srcFound.transceiver.find(
+                  (v) => v.type === "wormhole"
+                )!.address,
+              },
+              quoter: srcFound.quoter,
+            },
+            dstContracts: {
+              token: dstFound.token,
+              manager: dstFound.manager,
+              transceiver: {
+                wormhole: dstFound.transceiver.find(
+                  (v) => v.type === "wormhole"
+                )!.address,
+              },
+            },
+          };
+        }
+      }
     }
-    throw new Error("Cannot find Ntt contracts in config for: " + address);
+
+    throw new Error("Cannot find Ntt contracts in config for: " + srcAddress);
   }
 
   export function resolveDestinationNttContracts<C extends Chain>(