@m0-foundation/ntt-sdk-route 0.0.2

package/README.md

@@ -0,0 +1,4 @@
+# M0 Custom NTT Route
+
+The package extends `NttAutomaticRoute` to support `transferMLikeToken` function from M0 `Portal` contract 
+

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+import { Network, routes, Chain, ChainContext, TokenId, Signer, ChainAddress, AccountAddress } from '@wormhole-foundation/sdk-connect';
+import { Ntt } from '@wormhole-foundation/sdk-definitions-ntt';
+import { EvmNtt } from '@wormhole-foundation/sdk-evm-ntt';
+import { EvmChains, EvmUnsignedTransaction } from '@wormhole-foundation/sdk-evm';
+import { NttRoute } from '@wormhole-foundation/sdk-route-ntt';
+import { TransactionRequest } from 'ethers';
+
+type Op = NttRoute.Options;
+type Tp = routes.TransferParams<Op>;
+type Vr = routes.ValidationResult<Op>;
+type Vp = NttRoute.ValidatedParams;
+type QR = routes.QuoteResult<Op, Vp>;
+type Q = routes.Quote<Op, Vp>;
+type R = NttRoute.AutomaticTransferReceipt;
+type Contracts = Ntt.Contracts & {
+    wrappedMToken: string;
+};
+declare class M0AutomaticRoute<N extends Network> extends routes.AutomaticRoute<N, Op, Vp, R> implements routes.StaticRouteMethods<typeof M0AutomaticRoute> {
+    static NATIVE_GAS_DROPOFF_SUPPORTED: boolean;
+    static EVM_CONTRACTS: Contracts;
+    static meta: {
+        name: string;
+        provider: string;
+    };
+    static supportedNetworks(): Network[];
+    static supportedChains(network: Network): Chain[];
+    static getContracts(chain: Chain): Contracts;
+    static supportedSourceTokens(fromChain: ChainContext<Network>): Promise<TokenId[]>;
+    static supportedDestinationTokens<N extends Network>(token: TokenId, fromChain: ChainContext<N>, toChain: ChainContext<N>): Promise<TokenId[]>;
+    static isProtocolSupported<N extends Network>(chain: ChainContext<N>): boolean;
+    getDefaultOptions(): Op;
+    isAvailable(request: routes.RouteTransferRequest<N>): Promise<boolean>;
+    validate(request: routes.RouteTransferRequest<N>, params: Tp): Promise<Vr>;
+    quote(request: routes.RouteTransferRequest<N>, params: Vp): Promise<QR>;
+    initiate(request: routes.RouteTransferRequest<N>, signer: Signer, quote: Q, to: ChainAddress): Promise<R>;
+    /**
+     * Modified from EvmNtt `transfer` function to call `transferMLikeToken` instead
+     * https://github.com/wormhole-foundation/native-token-transfers/blob/main/evm/ts/src/ntt.ts#L461
+     */
+    transferMLike<N extends Network, C extends EvmChains>(ntt: EvmNtt<N, C>, sender: AccountAddress<C>, amount: bigint, destination: ChainAddress, sourceToken: string, destinationToken: string, options: Ntt.TransferOptions): AsyncGenerator<EvmUnsignedTransaction<N, C>>;
+    createUnsignedTx<N extends Network, C extends EvmChains>(ntt: EvmNtt<N, C>, txReq: TransactionRequest, description: string, parallelizable?: boolean): EvmUnsignedTransaction<N, C>;
+    track(receipt: R, timeout?: number): AsyncGenerator<R, void, unknown>;
+}
+
+export { M0AutomaticRoute };

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { Network, routes, Chain, ChainContext, TokenId, Signer, ChainAddress, AccountAddress } from '@wormhole-foundation/sdk-connect';
+import { Ntt } from '@wormhole-foundation/sdk-definitions-ntt';
+import { EvmNtt } from '@wormhole-foundation/sdk-evm-ntt';
+import { EvmChains, EvmUnsignedTransaction } from '@wormhole-foundation/sdk-evm';
+import { NttRoute } from '@wormhole-foundation/sdk-route-ntt';
+import { TransactionRequest } from 'ethers';
+
+type Op = NttRoute.Options;
+type Tp = routes.TransferParams<Op>;
+type Vr = routes.ValidationResult<Op>;
+type Vp = NttRoute.ValidatedParams;
+type QR = routes.QuoteResult<Op, Vp>;
+type Q = routes.Quote<Op, Vp>;
+type R = NttRoute.AutomaticTransferReceipt;
+type Contracts = Ntt.Contracts & {
+    wrappedMToken: string;
+};
+declare class M0AutomaticRoute<N extends Network> extends routes.AutomaticRoute<N, Op, Vp, R> implements routes.StaticRouteMethods<typeof M0AutomaticRoute> {
+    static NATIVE_GAS_DROPOFF_SUPPORTED: boolean;
+    static EVM_CONTRACTS: Contracts;
+    static meta: {
+        name: string;
+        provider: string;
+    };
+    static supportedNetworks(): Network[];
+    static supportedChains(network: Network): Chain[];
+    static getContracts(chain: Chain): Contracts;
+    static supportedSourceTokens(fromChain: ChainContext<Network>): Promise<TokenId[]>;
+    static supportedDestinationTokens<N extends Network>(token: TokenId, fromChain: ChainContext<N>, toChain: ChainContext<N>): Promise<TokenId[]>;
+    static isProtocolSupported<N extends Network>(chain: ChainContext<N>): boolean;
+    getDefaultOptions(): Op;
+    isAvailable(request: routes.RouteTransferRequest<N>): Promise<boolean>;
+    validate(request: routes.RouteTransferRequest<N>, params: Tp): Promise<Vr>;
+    quote(request: routes.RouteTransferRequest<N>, params: Vp): Promise<QR>;
+    initiate(request: routes.RouteTransferRequest<N>, signer: Signer, quote: Q, to: ChainAddress): Promise<R>;
+    /**
+     * Modified from EvmNtt `transfer` function to call `transferMLikeToken` instead
+     * https://github.com/wormhole-foundation/native-token-transfers/blob/main/evm/ts/src/ntt.ts#L461
+     */
+    transferMLike<N extends Network, C extends EvmChains>(ntt: EvmNtt<N, C>, sender: AccountAddress<C>, amount: bigint, destination: ChainAddress, sourceToken: string, destinationToken: string, options: Ntt.TransferOptions): AsyncGenerator<EvmUnsignedTransaction<N, C>>;
+    createUnsignedTx<N extends Network, C extends EvmChains>(ntt: EvmNtt<N, C>, txReq: TransactionRequest, description: string, parallelizable?: boolean): EvmUnsignedTransaction<N, C>;
+    track(receipt: R, timeout?: number): AsyncGenerator<R, void, unknown>;
+}
+
+export { M0AutomaticRoute };

package/dist/index.js

@@ -0,0 +1,302 @@
+'use strict';
+
+var sdkConnect = require('@wormhole-foundation/sdk-connect');
+var sdkDefinitionsNtt = require('@wormhole-foundation/sdk-definitions-ntt');
+var sdkEvm = require('@wormhole-foundation/sdk-evm');
+var sdkRouteNtt = require('@wormhole-foundation/sdk-route-ntt');
+var ethers = require('ethers');
+
+// src/m0AutomaticRoute.ts
+var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.AutomaticRoute {
+  static supportedNetworks() {
+    return ["Mainnet", "Testnet"];
+  }
+  static supportedChains(network) {
+    switch (network) {
+      case "Mainnet":
+        return ["Ethereum", "Arbitrum", "Optimism"];
+      case "Testnet":
+        return ["Sepolia", "ArbitrumSepolia", "OptimismSepolia"];
+      default:
+        throw new Error(`Unsupported network: ${network}`);
+    }
+  }
+  static getContracts(chain) {
+    switch (chain) {
+      case "Ethereum":
+        return this.EVM_CONTRACTS;
+      case "Optimism":
+        return this.EVM_CONTRACTS;
+      case "Arbitrum":
+        return this.EVM_CONTRACTS;
+      case "Sepolia":
+        return this.EVM_CONTRACTS;
+      case "OptimismSepolia":
+        return this.EVM_CONTRACTS;
+      case "ArbitrumSepolia":
+        return this.EVM_CONTRACTS;
+      default:
+        throw new Error(`Unsupported chain: ${chain}`);
+    }
+  }
+  static async supportedSourceTokens(fromChain) {
+    const { token, wrappedMToken } = this.getContracts(fromChain.chain);
+    return [
+      sdkConnect.Wormhole.tokenId(fromChain.chain, token),
+      sdkConnect.Wormhole.tokenId(fromChain.chain, wrappedMToken)
+    ];
+  }
+  static async supportedDestinationTokens(token, fromChain, toChain) {
+    const { token: mToken, wrappedMToken } = this.getContracts(toChain.chain);
+    return [
+      sdkConnect.Wormhole.tokenId(toChain.chain, mToken),
+      sdkConnect.Wormhole.tokenId(toChain.chain, wrappedMToken)
+    ];
+  }
+  static isProtocolSupported(chain) {
+    return chain.supportsProtocol("Ntt");
+  }
+  getDefaultOptions() {
+    return sdkRouteNtt.NttRoute.AutomaticOptions;
+  }
+  async isAvailable(request) {
+    const ntt = await request.fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(request.fromChain.chain)
+    });
+    return ntt.isRelayingAvailable(request.toChain.chain);
+  }
+  async validate(request, params) {
+    const options = params.options ?? this.getDefaultOptions();
+    const gasDropoff = sdkConnect.amount.parse(
+      options.gasDropoff ?? "0.0",
+      request.toChain.config.nativeTokenDecimals
+    );
+    const parsedAmount = sdkConnect.amount.parse(params.amount, request.source.decimals);
+    const trimmedAmount = sdkRouteNtt.NttRoute.trimAmount(
+      parsedAmount,
+      request.destination.decimals
+    );
+    const fromContracts = _M0AutomaticRoute.getContracts(
+      request.fromChain.chain
+    );
+    const toContracts = _M0AutomaticRoute.getContracts(request.toChain.chain);
+    const validatedParams = {
+      amount: params.amount,
+      normalizedParams: {
+        amount: trimmedAmount,
+        sourceContracts: fromContracts,
+        destinationContracts: toContracts,
+        options: {
+          queue: false,
+          automatic: true,
+          gasDropoff: sdkConnect.amount.units(gasDropoff)
+        }
+      },
+      options
+    };
+    return { valid: true, params: validatedParams };
+  }
+  async quote(request, params) {
+    const { fromChain, toChain } = request;
+    const ntt = await fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(fromChain.chain)
+    });
+    if (!await ntt.isRelayingAvailable(toChain.chain)) {
+      return {
+        success: false,
+        error: new Error(`Relaying to chain ${toChain.chain} is not available`)
+      };
+    }
+    const deliveryPrice = await ntt.quoteDeliveryPrice(
+      toChain.chain,
+      params.normalizedParams.options
+    );
+    const dstAmount = sdkConnect.amount.scale(
+      params.normalizedParams.amount,
+      request.destination.decimals
+    );
+    const result = {
+      success: true,
+      params,
+      sourceToken: {
+        token: request.source.id,
+        amount: params.normalizedParams.amount
+      },
+      destinationToken: {
+        token: request.destination.id,
+        amount: dstAmount
+      },
+      relayFee: {
+        token: sdkConnect.Wormhole.tokenId(fromChain.chain, "native"),
+        amount: sdkConnect.amount.fromBaseUnits(
+          deliveryPrice,
+          fromChain.config.nativeTokenDecimals
+        )
+      },
+      destinationNativeGas: sdkConnect.amount.fromBaseUnits(
+        params.normalizedParams.options.gasDropoff ?? 0n,
+        toChain.config.nativeTokenDecimals
+      ),
+      eta: sdkConnect.finality.estimateFinalityTime(request.fromChain.chain)
+    };
+    return result;
+  }
+  async initiate(request, signer, quote, to) {
+    const { params } = quote;
+    const { fromChain } = request;
+    const sender = sdkConnect.Wormhole.parseAddress(signer.chain(), signer.address());
+    if (sdkConnect.chainToPlatform(fromChain.chain) !== "Evm")
+      throw new Error("The route supports only EVM");
+    const ntt = await fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(fromChain.chain)
+    });
+    const sourceTokenAddress = sdkConnect.canonicalAddress(request.source.id);
+    const destinationTokenAddress = sdkConnect.canonicalAddress(request.destination.id);
+    const initXfer = this.transferMLike(
+      ntt,
+      sender,
+      sdkConnect.amount.units(params.normalizedParams.amount),
+      to,
+      sourceTokenAddress,
+      destinationTokenAddress,
+      params.normalizedParams.options
+    );
+    const txids = await sdkConnect.signSendWait(fromChain, initXfer, signer);
+    return {
+      from: fromChain.chain,
+      to: to.chain,
+      state: sdkConnect.TransferState.SourceInitiated,
+      originTxs: txids,
+      params
+    };
+  }
+  /**
+   * Modified from EvmNtt `transfer` function to call `transferMLikeToken` instead
+   * https://github.com/wormhole-foundation/native-token-transfers/blob/main/evm/ts/src/ntt.ts#L461
+   */
+  async *transferMLike(ntt, sender, amount2, destination, sourceToken, destinationToken, options) {
+    const senderAddress = new sdkEvm.EvmAddress(sender).toString();
+    const totalPrice = await ntt.quoteDeliveryPrice(destination.chain, options);
+    const tokenContract = sdkEvm.EvmPlatform.getTokenImplementation(
+      ntt.provider,
+      sourceToken
+    );
+    const allowance = await tokenContract.allowance(
+      senderAddress,
+      ntt.managerAddress
+    );
+    if (allowance < amount2) {
+      const txReq2 = await tokenContract.approve.populateTransaction(
+        ntt.managerAddress,
+        amount2
+      );
+      yield this.createUnsignedTx(
+        ntt,
+        sdkEvm.addFrom(txReq2, senderAddress),
+        "Ntt.Approve"
+      );
+    }
+    const receiver = sdkConnect.universalAddress(destination);
+    const contract = new ethers.Contract(ntt.managerAddress, [
+      "function transferMLikeToken(uint256 amount, address sourceToken, uint16 destinationChainId, bytes32 destinationToken, bytes32 recipient, bytes32 refundAddress) external payable returns (uint64 sequence)"
+    ]);
+    const txReq = await contract.getFunction("transferMLikeToken").populateTransaction(
+      amount2,
+      sourceToken,
+      sdkConnect.toChainId(destination.chain),
+      sdkConnect.toUniversal(destination.chain, destinationToken).toString(),
+      receiver,
+      receiver,
+      { value: totalPrice }
+    );
+    yield ntt.createUnsignedTx(sdkEvm.addFrom(txReq, senderAddress), "Ntt.transfer");
+  }
+  createUnsignedTx(ntt, txReq, description, parallelizable = false) {
+    return new sdkEvm.EvmUnsignedTransaction(
+      sdkEvm.addChainId(txReq, ntt.chainId),
+      ntt.network,
+      ntt.chain,
+      description,
+      parallelizable
+    );
+  }
+  async *track(receipt, timeout) {
+    if (sdkConnect.isSourceInitiated(receipt) || sdkConnect.isSourceFinalized(receipt)) {
+      const { txid } = receipt.originTxs[receipt.originTxs.length - 1];
+      const isEvmPlatform = (chain) => sdkConnect.chainToPlatform(chain) === "Evm";
+      const vaaType = isEvmPlatform(receipt.from) && isEvmPlatform(receipt.to) ? (
+        // Automatic NTT transfers between EVM chains use standard relayers
+        "Ntt:WormholeTransferStandardRelayer"
+      ) : "Ntt:WormholeTransfer";
+      const vaa = await this.wh.getVaa(txid, vaaType, timeout);
+      if (!vaa) {
+        throw new Error(`No VAA found for transaction: ${txid}`);
+      }
+      const msgId = {
+        chain: vaa.emitterChain,
+        emitter: vaa.emitterAddress,
+        sequence: vaa.sequence
+      };
+      receipt = {
+        ...receipt,
+        state: sdkConnect.TransferState.Attested,
+        attestation: {
+          id: msgId,
+          attestation: vaa
+        }
+      };
+      yield receipt;
+    }
+    const toChain = this.wh.getChain(receipt.to);
+    const ntt = await toChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(toChain.chain)
+    });
+    if (sdkConnect.isAttested(receipt)) {
+      const {
+        attestation: { attestation: vaa }
+      } = receipt;
+      if (await ntt.getIsApproved(vaa)) {
+        receipt = {
+          ...receipt,
+          state: sdkConnect.TransferState.DestinationInitiated
+          // TODO: check for destination event transactions to get dest Txids
+        };
+        yield receipt;
+      }
+    }
+    if (sdkConnect.isRedeemed(receipt)) {
+      const {
+        attestation: { attestation: vaa }
+      } = receipt;
+      const payload = vaa.payloadName === "WormholeTransfer" ? vaa.payload : vaa.payload["payload"];
+      const isExecuted = await ntt.manager.isMessageExecuted(
+        sdkDefinitionsNtt.Ntt.messageDigest(vaa.emitterChain, payload["nttManagerPayload"])
+      );
+      if (isExecuted) {
+        receipt = {
+          ...receipt,
+          state: sdkConnect.TransferState.DestinationFinalized
+        };
+        yield receipt;
+      }
+    }
+    yield receipt;
+  }
+};
+// ntt does not support gas drop-off currently
+_M0AutomaticRoute.NATIVE_GAS_DROPOFF_SUPPORTED = false;
+// Contract addresses are the same on all EVM chains
+_M0AutomaticRoute.EVM_CONTRACTS = {
+  // M token address is the same on EVM chains
+  token: "0x866A2BF4E572CbcF37D5071A7a58503Bfb36be1b",
+  // Wrapped M token address is the same on EVM chains
+  wrappedMToken: "0x437cc33344a0B27A429f795ff6B469C72698B291",
+  // M0 Portal address is the same on EVM chains
+  manager: "0xD925C84b55E4e44a53749fF5F2a5A13F63D128fd",
+  // Wormhole transceiver address is the same on EVM chains
+  transceiver: { wormhole: "0x0763196A091575adF99e2306E5e90E0Be5154841" }
+};
+_M0AutomaticRoute.meta = { name: "M0AutomaticRoute", provider: "M^0" };
+var M0AutomaticRoute = _M0AutomaticRoute;
+
+exports.M0AutomaticRoute = M0AutomaticRoute;

package/dist/index.mjs

@@ -0,0 +1,300 @@
+import { routes, Wormhole, amount, finality, chainToPlatform, canonicalAddress, signSendWait, TransferState, universalAddress, toChainId, toUniversal, isSourceInitiated, isSourceFinalized, isAttested, isRedeemed } from '@wormhole-foundation/sdk-connect';
+import { Ntt } from '@wormhole-foundation/sdk-definitions-ntt';
+import { EvmAddress, EvmPlatform, addFrom, EvmUnsignedTransaction, addChainId } from '@wormhole-foundation/sdk-evm';
+import { NttRoute } from '@wormhole-foundation/sdk-route-ntt';
+import { Contract } from 'ethers';
+
+// src/m0AutomaticRoute.ts
+var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
+  static supportedNetworks() {
+    return ["Mainnet", "Testnet"];
+  }
+  static supportedChains(network) {
+    switch (network) {
+      case "Mainnet":
+        return ["Ethereum", "Arbitrum", "Optimism"];
+      case "Testnet":
+        return ["Sepolia", "ArbitrumSepolia", "OptimismSepolia"];
+      default:
+        throw new Error(`Unsupported network: ${network}`);
+    }
+  }
+  static getContracts(chain) {
+    switch (chain) {
+      case "Ethereum":
+        return this.EVM_CONTRACTS;
+      case "Optimism":
+        return this.EVM_CONTRACTS;
+      case "Arbitrum":
+        return this.EVM_CONTRACTS;
+      case "Sepolia":
+        return this.EVM_CONTRACTS;
+      case "OptimismSepolia":
+        return this.EVM_CONTRACTS;
+      case "ArbitrumSepolia":
+        return this.EVM_CONTRACTS;
+      default:
+        throw new Error(`Unsupported chain: ${chain}`);
+    }
+  }
+  static async supportedSourceTokens(fromChain) {
+    const { token, wrappedMToken } = this.getContracts(fromChain.chain);
+    return [
+      Wormhole.tokenId(fromChain.chain, token),
+      Wormhole.tokenId(fromChain.chain, wrappedMToken)
+    ];
+  }
+  static async supportedDestinationTokens(token, fromChain, toChain) {
+    const { token: mToken, wrappedMToken } = this.getContracts(toChain.chain);
+    return [
+      Wormhole.tokenId(toChain.chain, mToken),
+      Wormhole.tokenId(toChain.chain, wrappedMToken)
+    ];
+  }
+  static isProtocolSupported(chain) {
+    return chain.supportsProtocol("Ntt");
+  }
+  getDefaultOptions() {
+    return NttRoute.AutomaticOptions;
+  }
+  async isAvailable(request) {
+    const ntt = await request.fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(request.fromChain.chain)
+    });
+    return ntt.isRelayingAvailable(request.toChain.chain);
+  }
+  async validate(request, params) {
+    const options = params.options ?? this.getDefaultOptions();
+    const gasDropoff = amount.parse(
+      options.gasDropoff ?? "0.0",
+      request.toChain.config.nativeTokenDecimals
+    );
+    const parsedAmount = amount.parse(params.amount, request.source.decimals);
+    const trimmedAmount = NttRoute.trimAmount(
+      parsedAmount,
+      request.destination.decimals
+    );
+    const fromContracts = _M0AutomaticRoute.getContracts(
+      request.fromChain.chain
+    );
+    const toContracts = _M0AutomaticRoute.getContracts(request.toChain.chain);
+    const validatedParams = {
+      amount: params.amount,
+      normalizedParams: {
+        amount: trimmedAmount,
+        sourceContracts: fromContracts,
+        destinationContracts: toContracts,
+        options: {
+          queue: false,
+          automatic: true,
+          gasDropoff: amount.units(gasDropoff)
+        }
+      },
+      options
+    };
+    return { valid: true, params: validatedParams };
+  }
+  async quote(request, params) {
+    const { fromChain, toChain } = request;
+    const ntt = await fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(fromChain.chain)
+    });
+    if (!await ntt.isRelayingAvailable(toChain.chain)) {
+      return {
+        success: false,
+        error: new Error(`Relaying to chain ${toChain.chain} is not available`)
+      };
+    }
+    const deliveryPrice = await ntt.quoteDeliveryPrice(
+      toChain.chain,
+      params.normalizedParams.options
+    );
+    const dstAmount = amount.scale(
+      params.normalizedParams.amount,
+      request.destination.decimals
+    );
+    const result = {
+      success: true,
+      params,
+      sourceToken: {
+        token: request.source.id,
+        amount: params.normalizedParams.amount
+      },
+      destinationToken: {
+        token: request.destination.id,
+        amount: dstAmount
+      },
+      relayFee: {
+        token: Wormhole.tokenId(fromChain.chain, "native"),
+        amount: amount.fromBaseUnits(
+          deliveryPrice,
+          fromChain.config.nativeTokenDecimals
+        )
+      },
+      destinationNativeGas: amount.fromBaseUnits(
+        params.normalizedParams.options.gasDropoff ?? 0n,
+        toChain.config.nativeTokenDecimals
+      ),
+      eta: finality.estimateFinalityTime(request.fromChain.chain)
+    };
+    return result;
+  }
+  async initiate(request, signer, quote, to) {
+    const { params } = quote;
+    const { fromChain } = request;
+    const sender = Wormhole.parseAddress(signer.chain(), signer.address());
+    if (chainToPlatform(fromChain.chain) !== "Evm")
+      throw new Error("The route supports only EVM");
+    const ntt = await fromChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(fromChain.chain)
+    });
+    const sourceTokenAddress = canonicalAddress(request.source.id);
+    const destinationTokenAddress = canonicalAddress(request.destination.id);
+    const initXfer = this.transferMLike(
+      ntt,
+      sender,
+      amount.units(params.normalizedParams.amount),
+      to,
+      sourceTokenAddress,
+      destinationTokenAddress,
+      params.normalizedParams.options
+    );
+    const txids = await signSendWait(fromChain, initXfer, signer);
+    return {
+      from: fromChain.chain,
+      to: to.chain,
+      state: TransferState.SourceInitiated,
+      originTxs: txids,
+      params
+    };
+  }
+  /**
+   * Modified from EvmNtt `transfer` function to call `transferMLikeToken` instead
+   * https://github.com/wormhole-foundation/native-token-transfers/blob/main/evm/ts/src/ntt.ts#L461
+   */
+  async *transferMLike(ntt, sender, amount2, destination, sourceToken, destinationToken, options) {
+    const senderAddress = new EvmAddress(sender).toString();
+    const totalPrice = await ntt.quoteDeliveryPrice(destination.chain, options);
+    const tokenContract = EvmPlatform.getTokenImplementation(
+      ntt.provider,
+      sourceToken
+    );
+    const allowance = await tokenContract.allowance(
+      senderAddress,
+      ntt.managerAddress
+    );
+    if (allowance < amount2) {
+      const txReq2 = await tokenContract.approve.populateTransaction(
+        ntt.managerAddress,
+        amount2
+      );
+      yield this.createUnsignedTx(
+        ntt,
+        addFrom(txReq2, senderAddress),
+        "Ntt.Approve"
+      );
+    }
+    const receiver = universalAddress(destination);
+    const contract = new Contract(ntt.managerAddress, [
+      "function transferMLikeToken(uint256 amount, address sourceToken, uint16 destinationChainId, bytes32 destinationToken, bytes32 recipient, bytes32 refundAddress) external payable returns (uint64 sequence)"
+    ]);
+    const txReq = await contract.getFunction("transferMLikeToken").populateTransaction(
+      amount2,
+      sourceToken,
+      toChainId(destination.chain),
+      toUniversal(destination.chain, destinationToken).toString(),
+      receiver,
+      receiver,
+      { value: totalPrice }
+    );
+    yield ntt.createUnsignedTx(addFrom(txReq, senderAddress), "Ntt.transfer");
+  }
+  createUnsignedTx(ntt, txReq, description, parallelizable = false) {
+    return new EvmUnsignedTransaction(
+      addChainId(txReq, ntt.chainId),
+      ntt.network,
+      ntt.chain,
+      description,
+      parallelizable
+    );
+  }
+  async *track(receipt, timeout) {
+    if (isSourceInitiated(receipt) || isSourceFinalized(receipt)) {
+      const { txid } = receipt.originTxs[receipt.originTxs.length - 1];
+      const isEvmPlatform = (chain) => chainToPlatform(chain) === "Evm";
+      const vaaType = isEvmPlatform(receipt.from) && isEvmPlatform(receipt.to) ? (
+        // Automatic NTT transfers between EVM chains use standard relayers
+        "Ntt:WormholeTransferStandardRelayer"
+      ) : "Ntt:WormholeTransfer";
+      const vaa = await this.wh.getVaa(txid, vaaType, timeout);
+      if (!vaa) {
+        throw new Error(`No VAA found for transaction: ${txid}`);
+      }
+      const msgId = {
+        chain: vaa.emitterChain,
+        emitter: vaa.emitterAddress,
+        sequence: vaa.sequence
+      };
+      receipt = {
+        ...receipt,
+        state: TransferState.Attested,
+        attestation: {
+          id: msgId,
+          attestation: vaa
+        }
+      };
+      yield receipt;
+    }
+    const toChain = this.wh.getChain(receipt.to);
+    const ntt = await toChain.getProtocol("Ntt", {
+      ntt: _M0AutomaticRoute.getContracts(toChain.chain)
+    });
+    if (isAttested(receipt)) {
+      const {
+        attestation: { attestation: vaa }
+      } = receipt;
+      if (await ntt.getIsApproved(vaa)) {
+        receipt = {
+          ...receipt,
+          state: TransferState.DestinationInitiated
+          // TODO: check for destination event transactions to get dest Txids
+        };
+        yield receipt;
+      }
+    }
+    if (isRedeemed(receipt)) {
+      const {
+        attestation: { attestation: vaa }
+      } = receipt;
+      const payload = vaa.payloadName === "WormholeTransfer" ? vaa.payload : vaa.payload["payload"];
+      const isExecuted = await ntt.manager.isMessageExecuted(
+        Ntt.messageDigest(vaa.emitterChain, payload["nttManagerPayload"])
+      );
+      if (isExecuted) {
+        receipt = {
+          ...receipt,
+          state: TransferState.DestinationFinalized
+        };
+        yield receipt;
+      }
+    }
+    yield receipt;
+  }
+};
+// ntt does not support gas drop-off currently
+_M0AutomaticRoute.NATIVE_GAS_DROPOFF_SUPPORTED = false;
+// Contract addresses are the same on all EVM chains
+_M0AutomaticRoute.EVM_CONTRACTS = {
+  // M token address is the same on EVM chains
+  token: "0x866A2BF4E572CbcF37D5071A7a58503Bfb36be1b",
+  // Wrapped M token address is the same on EVM chains
+  wrappedMToken: "0x437cc33344a0B27A429f795ff6B469C72698B291",
+  // M0 Portal address is the same on EVM chains
+  manager: "0xD925C84b55E4e44a53749fF5F2a5A13F63D128fd",
+  // Wormhole transceiver address is the same on EVM chains
+  transceiver: { wormhole: "0x0763196A091575adF99e2306E5e90E0Be5154841" }
+};
+_M0AutomaticRoute.meta = { name: "M0AutomaticRoute", provider: "M^0" };
+var M0AutomaticRoute = _M0AutomaticRoute;
+
+export { M0AutomaticRoute };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@m0-foundation/ntt-sdk-route",
+  "version": "0.0.2",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@changesets/cli": "^2.28.1",
+    "@types/node": "~20.17.17",
+    "tsup": "~8.3.6",
+    "typescript": "~5.6.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@wormhole-foundation/sdk": "^1.7.0",
+    "@wormhole-foundation/sdk-connect": "^1.7.0",
+    "@wormhole-foundation/sdk-definitions-ntt": "^0.6.1",
+    "@wormhole-foundation/sdk-evm": "^1.7.0",
+    "@wormhole-foundation/sdk-evm-ntt": "^0.6.1",
+    "@wormhole-foundation/sdk-route-ntt": "^0.6.1",
+    "ethers": "^6.5.1"
+  },
+  "scripts": {
+    "build": "$npm_execpath tsup --clean",
+    "clean": "rm -rf dist"
+  }
+}