@m0-foundation/ntt-sdk-route 0.0.9 → 0.0.11

package/dist/index.mjs

@@ -1,23 +1,564 @@
-import { routes, Wormhole, isSameToken, chainToPlatform, amount, finality, canonicalAddress, signSendWait, TransferState, universalAddress, toChainId, toUniversal, isSourceInitiated, isSourceFinalized, isAttested, isRedeemed } from '@wormhole-foundation/sdk-connect';
+import { routes, Wormhole, isSameToken, amount, finality, chainToPlatform, canonicalAddress, signSendWait, TransferState, universalAddress, toChainId, toUniversal, isSourceInitiated, isSourceFinalized, isAttested, isRedeemed, chainToChainId } from '@wormhole-foundation/sdk-connect';
 import { Ntt } from '@wormhole-foundation/sdk-definitions-ntt';
-import '@wormhole-foundation/sdk-solana-ntt';
+import { WEI_PER_GWEI, NTT } from '@wormhole-foundation/sdk-solana-ntt';
 import { EvmAddress, EvmPlatform, addFrom, EvmUnsignedTransaction, addChainId } from '@wormhole-foundation/sdk-evm';
-import '@wormhole-foundation/sdk-solana';
+import { SolanaAddress } from '@wormhole-foundation/sdk-solana';
 import { NttRoute } from '@wormhole-foundation/sdk-route-ntt';
 import { Contract } from 'ethers';
+import { Keypair, PublicKey, Transaction, LAMPORTS_PER_SOL, TransactionMessage, VersionedTransaction, TransactionInstruction, SystemProgram, AddressLookupTableAccount } from '@solana/web3.js';
+import { TOKEN_2022_PROGRAM_ID, getAssociatedTokenAddressSync, createAssociatedTokenAccountInstruction } from '@solana/spl-token';
+import BN from 'bn.js';
+import { sha256 } from '@noble/hashes/sha2';
 
 // src/m0AutomaticRoute.ts
-var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
-  static solanaContracts(network) {
+var SolanaRoutes = class _SolanaRoutes {
+  constructor(ntt) {
+    this.ntt = ntt;
+    this.network = ntt.network;
+    this.programs = _SolanaRoutes.getPrograms(this.network);
+    this.extPrograms = _SolanaRoutes.getExtPrograms(this.network);
+  }
+  static getPrograms(network) {
+    return {
+      Mainnet: {
+        swap: pk("MSwapi3WhNKMUGm9YrxGhypgUEt7wYQH3ZgG32XoWzH"),
+        earn: pk("mz2vDzjbQDUDXBH6FPF5s4odCJ4y8YLE5QWaZ8XdZ9Z"),
+        lut: pk("9JLRqBqkznKiSoNfotA4ywSRdnWb2fE76SiFrAfkaRCD"),
+        mMint: pk("mzerokyEX9TNDoK4o2YZQBDmMzjokAeN6M2g2S3pLJo"),
+        portal: pk("mzp1q2j5Hr1QuLC3KFBCAUz5aUckT6qyuZKZ3WJnMmY"),
+        quoter: pk("Nqd6XqA8LbsCuG8MLWWuP865NV6jR1MbXeKxD4HLKDJ")
+      },
+      Testnet: {
+        swap: pk("MSwapi3WhNKMUGm9YrxGhypgUEt7wYQH3ZgG32XoWzH"),
+        earn: pk("mz2vDzjbQDUDXBH6FPF5s4odCJ4y8YLE5QWaZ8XdZ9Z"),
+        lut: pk("6GhuWPuAmiJeeSVsr58KjqHcAejJRndCx9BVtHkaYHUR"),
+        mMint: pk("mzeroZRGCah3j5xEWp2Nih3GDejSBbH1rbHoxDg8By6"),
+        portal: pk("mzp1q2j5Hr1QuLC3KFBCAUz5aUckT6qyuZKZ3WJnMmY"),
+        quoter: pk("Nqd6XqA8LbsCuG8MLWWuP865NV6jR1MbXeKxD4HLKDJ")
+      }
+    }[network];
+  }
+  static getExtPrograms(network) {
+    return {
+      Mainnet: {
+        mzeroXDoBpRVhnEXBra27qzAMdxgpWVY3DzQW7xMVJp: {
+          program: pk("wMXX1K1nca5W4pZr1piETe78gcAVVrEFi9f4g46uXko"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        },
+        usdkbee86pkLyRmxfFCdkyySpxRb5ndCxVsK2BkRXwX: {
+          program: pk("extaykYu5AQcDm3qZAbiDN3yp6skqn6Nssj7veUUGZw"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        },
+        usdkyPPxgV7sfNyKb8eDz66ogPrkRXG3wS2FVb6LLUf: {
+          program: pk("extMahs9bUFMYcviKCvnSRaXgs5PcqmMzcnHRtTqE85"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        }
+      },
+      Testnet: {
+        mzeroXDoBpRVhnEXBra27qzAMdxgpWVY3DzQW7xMVJp: {
+          program: pk("wMXX1K1nca5W4pZr1piETe78gcAVVrEFi9f4g46uXko"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        },
+        usdkbee86pkLyRmxfFCdkyySpxRb5ndCxVsK2BkRXwX: {
+          program: pk("Fb2AsCKmPd4gKhabT6KsremSHMrJ8G2Mopnc6rDQZX9e"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        },
+        usdkyPPxgV7sfNyKb8eDz66ogPrkRXG3wS2FVb6LLUf: {
+          program: pk("3PskKTHgboCbUSQPMcCAZdZNFHbNvSoZ8zEFYANCdob7"),
+          tokenProgram: TOKEN_2022_PROGRAM_ID
+        }
+      }
+    }[network];
+  }
+  static getSolanaContracts(chainContext) {
+    const programs = _SolanaRoutes.getPrograms(
+      chainContext.network
+    );
+    const extPrograms = _SolanaRoutes.getExtPrograms(
+      chainContext.network
+    );
     return {
-      token: network == "Mainnet" ? this.SOLANA_MAINNET_M_TOKEN : this.SOLANA_TESTNET_M_TOKEN,
-      // Only M token can be bridged from Solana
-      mLikeTokens: [],
-      manager: "mzp1q2j5Hr1QuLC3KFBCAUz5aUckT6qyuZKZ3WJnMmY",
-      transceiver: { wormhole: "mzp1q2j5Hr1QuLC3KFBCAUz5aUckT6qyuZKZ3WJnMmY" },
-      quoter: "Nqd6XqA8LbsCuG8MLWWuP865NV6jR1MbXeKxD4HLKDJ"
+      token: programs.mMint.toBase58(),
+      mLikeTokens: Object.keys(extPrograms),
+      manager: programs.portal.toBase58(),
+      transceiver: { wormhole: programs.portal.toBase58() },
+      quoter: programs.quoter.toBase58()
     };
   }
+  getTransferExtensionBurnIx(amount2, recipient, payer, outboxItem, extMint, destinationToken, shouldQueue = true) {
+    const recipientAddress = Buffer.alloc(32);
+    const dest = Buffer.from(recipient.address.toUint8Array());
+    dest.copy(recipientAddress);
+    if (destinationToken.length !== 32) {
+      throw new Error(
+        `destinationToken must be 32 bytes, got ${destinationToken.length} bytes`
+      );
+    }
+    const extension = this.extPrograms[extMint.toBase58()];
+    if (!extension) {
+      throw new Error(
+        `No extension program found for mint ${extMint.toBase58()}`
+      );
+    }
+    const { program: extProgram, tokenProgram: extTokenProgram } = extension;
+    return new TransactionInstruction({
+      programId: this.ntt.program.programId,
+      keys: [
+        {
+          pubkey: payer,
+          isSigner: true,
+          isWritable: true
+        },
+        {
+          // config
+          pubkey: this.ntt.pdas.configAccount(),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // m mint
+          pubkey: this.programs.mMint,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // from (token auth m token account)
+          pubkey: getAssociatedTokenAddressSync(
+            this.programs.mMint,
+            PublicKey.findProgramAddressSync(
+              [Buffer.from("token_authority")],
+              this.ntt.program.programId
+            )[0],
+            true,
+            TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // m token program
+          pubkey: TOKEN_2022_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // outbox item
+          pubkey: outboxItem,
+          isSigner: true,
+          isWritable: true
+        },
+        {
+          // outbox rate limit
+          pubkey: this.ntt.pdas.outboxRateLimitAccount(),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // custody
+          pubkey: this.ntt.config.custody,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // system program
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // inbox rate limit
+          pubkey: this.ntt.pdas.inboxRateLimitAccount(recipient.chain),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // peer
+          pubkey: this.ntt.pdas.peerAccount(recipient.chain),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // session auth
+          pubkey: this.ntt.pdas.sessionAuthority(payer, {
+            amount: new BN(amount2),
+            recipientChain: {
+              id: 2
+              // Ethereum
+            },
+            recipientAddress: [...Array(32)],
+            shouldQueue: false
+          }),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // token auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("token_authority")],
+            this.ntt.program.programId
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint
+          pubkey: extMint,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // swap global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.swap
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // m global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.earn
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext token account
+          pubkey: getAssociatedTokenAddressSync(
+            extMint,
+            payer,
+            true,
+            extTokenProgram
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault
+          pubkey: getAssociatedTokenAddressSync(
+            this.programs.mMint,
+            PublicKey.findProgramAddressSync(
+              [Buffer.from("m_vault")],
+              extProgram
+            )[0],
+            true,
+            TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("m_vault")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("mint_authority")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext program
+          pubkey: extProgram,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // swap program
+          pubkey: this.programs.swap,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext token program
+          pubkey: extTokenProgram,
+          isSigner: false,
+          isWritable: false
+        }
+      ],
+      data: Buffer.concat([
+        Buffer.from(sha256("global:transfer_extension_burn").subarray(0, 8)),
+        new BN(amount2).toArrayLike(Buffer, "le", 8),
+        // amount
+        new BN(chainToChainId(recipient.chain)).toArrayLike(Buffer, "le", 2),
+        // chain_id
+        recipientAddress,
+        // recipient_address
+        destinationToken,
+        // destination_token
+        Buffer.from([Number(shouldQueue)])
+        // should_queue
+      ])
+    });
+  }
+  getReleaseInboundMintExtensionIx(nttMessage, emitterChain, payer, extMint, extAta) {
+    const extension = this.extPrograms[extMint.toBase58()];
+    if (!extension) {
+      throw new Error(
+        `No extension program found for mint ${extMint.toBase58()}`
+      );
+    }
+    const { program: extProgram, tokenProgram: extTokenProgram } = extension;
+    return new TransactionInstruction({
+      programId: this.ntt.program.programId,
+      keys: [
+        {
+          pubkey: payer,
+          isSigner: true,
+          isWritable: true
+        },
+        {
+          // config
+          pubkey: this.ntt.pdas.configAccount(),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // inbox item
+          pubkey: this.ntt.pdas.inboxItemAccount(emitterChain, nttMessage),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // recipient (mint to token auth which wraps to user)
+          pubkey: getAssociatedTokenAddressSync(
+            this.ntt.config.mint,
+            PublicKey.findProgramAddressSync(
+              [Buffer.from("token_authority")],
+              this.ntt.program.programId
+            )[0],
+            true,
+            TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // token auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("token_authority")],
+            this.ntt.program.programId
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // m mint
+          pubkey: this.ntt.config.mint,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // m token program
+          pubkey: TOKEN_2022_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // custody
+          pubkey: this.ntt.config.custody,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // earn program
+          pubkey: this.programs.earn,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // m global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.earn
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint
+          pubkey: extMint,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // swap global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.swap
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext global
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("m_vault")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint auth
+          pubkey: PublicKey.findProgramAddressSync(
+            [Buffer.from("mint_authority")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext m vault
+          pubkey: getAssociatedTokenAddressSync(
+            this.ntt.config.mint,
+            PublicKey.findProgramAddressSync(
+              [Buffer.from("m_vault")],
+              extProgram
+            )[0],
+            true,
+            TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext token account
+          pubkey: extAta,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext token account
+          pubkey: this.programs.swap,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext program
+          pubkey: extProgram,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext token program
+          pubkey: extTokenProgram,
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // system program
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false
+        }
+      ],
+      data: Buffer.concat([
+        Buffer.from(
+          sha256("global:release_inbound_mint_extension").subarray(0, 8)
+        )
+      ])
+    });
+  }
+  async getAddressLookupTableAccounts(connection) {
+    const info = await connection.getAccountInfo(this.programs.lut);
+    return new AddressLookupTableAccount({
+      key: this.programs.lut,
+      state: AddressLookupTableAccount.deserialize(info.data)
+    });
+  }
+  static async createReleaseInboundMintInstruction(ntt, args) {
+    const router = new _SolanaRoutes(ntt);
+    const { additionalPayload } = args.nttMessage.payload;
+    if (additionalPayload.length < 40) {
+      throw new Error(
+        `Invalid additionalPayload length: ${additionalPayload.length}, expected at least 40 bytes`
+      );
+    }
+    const destinationMint = new PublicKey(
+      // first 8 bytes is the index, next 32 bytes is the mint address
+      additionalPayload.slice(8, 40)
+    );
+    if (destinationMint.equals(ntt.config.mint)) {
+      return [
+        await NTT.createReleaseInboundMintInstruction(
+          ntt.program,
+          ntt.config,
+          args
+        )
+      ];
+    }
+    const extPrograms = router.extPrograms[destinationMint.toBase58()];
+    if (!extPrograms) {
+      throw new Error(
+        `No extension program found for mint ${destinationMint.toBase58()}`
+      );
+    }
+    const extAta = getAssociatedTokenAddressSync(
+      destinationMint,
+      args.recipient,
+      true,
+      extPrograms.tokenProgram
+    );
+    const ixs = [];
+    const acctInfo = await ntt.connection.getAccountInfo(extAta);
+    if (acctInfo === null) {
+      ixs.push(
+        createAssociatedTokenAccountInstruction(
+          args.payer,
+          extAta,
+          args.recipient,
+          destinationMint,
+          extPrograms.tokenProgram
+        )
+      );
+    }
+    ixs.push(
+      router.getReleaseInboundMintExtensionIx(
+        args.nttMessage,
+        args.chain,
+        args.payer,
+        destinationMint,
+        extAta
+      )
+    );
+    return ixs;
+  }
+};
+function pk(address) {
+  return new PublicKey(address);
+}
+
+// src/m0AutomaticRoute.ts
+var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
   static supportedNetworks() {
     return ["Mainnet", "Testnet"];
   }
@@ -27,9 +568,15 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
   static supportedChains(network) {
     switch (network) {
       case "Mainnet":
-        return ["Ethereum", "Arbitrum", "Optimism", "Solana"];
+        return ["Ethereum", "Arbitrum", "Optimism", "Solana", "Fogo"];
       case "Testnet":
-        return ["Sepolia", "ArbitrumSepolia", "OptimismSepolia", "Solana"];
+        return [
+          "Sepolia",
+          "ArbitrumSepolia",
+          "OptimismSepolia",
+          "Solana",
+          "Fogo"
+        ];
       default:
         throw new Error(`Unsupported network: ${network}`);
     }
@@ -49,7 +596,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
       case "ArbitrumSepolia":
         return this.EVM_CONTRACTS;
       case "Solana":
-        return this.solanaContracts(chainContext.network);
+        return SolanaRoutes.getSolanaContracts(chainContext);
+      case "Fogo":
+        return SolanaRoutes.getSolanaContracts(chainContext);
       default:
         throw new Error(`Unsupported chain: ${chainContext.chain}`);
     }
@@ -67,8 +616,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
       return [];
     }
     const { token: mToken, mLikeTokens } = this.getContracts(toChain);
-    const toMToken = Wormhole.tokenId(toChain.chain, mToken);
-    return chainToPlatform(fromChain.chain) === "Solana" ? [toMToken] : [toMToken, ...mLikeTokens.map((x) => Wormhole.tokenId(toChain.chain, x))];
+    return [mToken, ...mLikeTokens].map(
+      (x) => Wormhole.tokenId(toChain.chain, x)
+    );
   }
   static isProtocolSupported(chain) {
     return chain.supportsProtocol("Ntt");
@@ -163,14 +713,38 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
     const platform = chainToPlatform(fromChain.chain);
     const transferAmount = amount.units(params.normalizedParams.amount);
     const options = params.normalizedParams.options;
-    if (platform !== "Evm" && platform !== "Solana")
+    if (!_M0AutomaticRoute.isPlatformSupported(platform))
       throw new Error(`Unsupported platform ${platform}`);
     const ntt = await fromChain.getProtocol("Ntt", {
       ntt: _M0AutomaticRoute.getContracts(fromChain)
     });
     const sourceToken = canonicalAddress(request.source.id);
     const destinationToken = canonicalAddress(request.destination.id);
-    const initXfer = platform === "Evm" ? this.transferMLike(ntt, sender, transferAmount, to, sourceToken, destinationToken, options) : ntt.transfer(sender, transferAmount, to, options);
+    const initXfer = platform === "Evm" ? (
+      // for EVM call transferMLike function
+      this.transferMLike(
+        ntt,
+        // @ts-ignore
+        sender,
+        transferAmount,
+        to,
+        sourceToken,
+        destinationToken,
+        options
+      )
+    ) : (
+      // for Solana use custom transfer instruction
+      this.transferSolanaExtension(
+        ntt,
+        // @ts-ignore
+        sender,
+        transferAmount,
+        to,
+        sourceToken,
+        destinationToken,
+        options
+      )
+    );
     const txids = await signSendWait(fromChain, initXfer, signer);
     return {
       from: fromChain.chain,
@@ -230,6 +804,75 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
       parallelizable
     );
   }
+  async *transferSolanaExtension(ntt, sender, amount2, recipient, sourceToken, destinationToken, options) {
+    const router = new SolanaRoutes(ntt);
+    if ((await ntt.getConfig()).mint.toBase58() === sourceToken) {
+      return ntt.transfer(sender, amount2, recipient, options);
+    }
+    const config = await ntt.getConfig();
+    if (config.paused) throw new Error("Contract is paused");
+    const outboxItem = Keypair.generate();
+    const payerAddress = new SolanaAddress(sender).unwrap();
+    const ixs = [
+      router.getTransferExtensionBurnIx(
+        amount2,
+        recipient,
+        new PublicKey(sender.toUint8Array()),
+        outboxItem.publicKey,
+        new PublicKey(sourceToken),
+        toUniversal(recipient.chain, destinationToken).toUint8Array(),
+        options.queue
+      )
+    ];
+    for (let ix = 0; ix < ntt.transceivers.length; ++ix) {
+      if (ix === 0) {
+        const whTransceiver = await ntt.getWormholeTransceiver();
+        if (!whTransceiver) {
+          throw new Error("wormhole transceiver not found");
+        }
+        const releaseIx = await whTransceiver.createReleaseWormholeOutboundIx(
+          payerAddress,
+          outboxItem.publicKey,
+          !options.queue
+        );
+        ixs.push(releaseIx);
+      }
+    }
+    const tx = new Transaction();
+    tx.feePayer = payerAddress;
+    tx.add(...ixs);
+    if (options.automatic) {
+      if (!ntt.quoter)
+        throw new Error(
+          "No quoter available, cannot initiate an automatic transfer."
+        );
+      const fee = await ntt.quoteDeliveryPrice(recipient.chain, options);
+      const relayIx = await ntt.quoter.createRequestRelayInstruction(
+        payerAddress,
+        outboxItem.publicKey,
+        recipient.chain,
+        Number(fee) / LAMPORTS_PER_SOL,
+        Number(options.gasDropoff ?? 0n) / WEI_PER_GWEI
+      );
+      tx.add(relayIx);
+    }
+    const luts = [];
+    try {
+      luts.push(await ntt.getAddressLookupTable());
+      luts.push(await router.getAddressLookupTableAccounts(ntt.connection));
+    } catch {
+    }
+    const messageV0 = new TransactionMessage({
+      payerKey: payerAddress,
+      instructions: tx.instructions,
+      recentBlockhash: (await ntt.connection.getLatestBlockhash()).blockhash
+    }).compileToV0Message(luts);
+    const vtx = new VersionedTransaction(messageV0);
+    yield ntt.createUnsignedTx(
+      { transaction: vtx, signers: [outboxItem] },
+      "Ntt.Transfer"
+    );
+  }
   async *track(receipt, timeout) {
     const isEvmPlatform = (chain) => chainToPlatform(chain) === "Evm";
     if (isSourceInitiated(receipt) || isSourceFinalized(receipt)) {
@@ -272,7 +915,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
       }
     }
     if (isRedeemed(receipt)) {
-      const { attestation: { attestation: vaa } } = receipt;
+      const {
+        attestation: { attestation: vaa }
+      } = receipt;
       const payload = vaa.payloadName === "WormholeTransfer" ? vaa.payload : vaa.payload["payload"];
       const isExecuted = isEvmPlatform(receipt.to) ? await ntt.manager.isMessageExecuted(
         Ntt.messageDigest(vaa.emitterChain, payload["nttManagerPayload"])
@@ -292,8 +937,6 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends routes.AutomaticRoute {
 _M0AutomaticRoute.NATIVE_GAS_DROPOFF_SUPPORTED = false;
 // Wrapped M token address is the same on EVM chains
 _M0AutomaticRoute.EVM_WRAPPED_M_TOKEN = "0x437cc33344a0B27A429f795ff6B469C72698B291";
-_M0AutomaticRoute.SOLANA_MAINNET_M_TOKEN = "mzerokyEX9TNDoK4o2YZQBDmMzjokAeN6M2g2S3pLJo";
-_M0AutomaticRoute.SOLANA_TESTNET_M_TOKEN = "mzeroZRGCah3j5xEWp2Nih3GDejSBbH1rbHoxDg8By6";
 // Contract addresses are the same on all EVM chains
 _M0AutomaticRoute.EVM_CONTRACTS = {
   // M token address is the same on EVM chains
@@ -308,4 +951,4 @@ _M0AutomaticRoute.EVM_CONTRACTS = {
 _M0AutomaticRoute.meta = { name: "M0AutomaticRoute", provider: "M0" };
 var M0AutomaticRoute = _M0AutomaticRoute;
 
-export { M0AutomaticRoute };
+export { M0AutomaticRoute, SolanaRoutes };