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

package/dist/index.js

@@ -2,24 +2,569 @@
 
 var sdkConnect = require('@wormhole-foundation/sdk-connect');
 var sdkDefinitionsNtt = require('@wormhole-foundation/sdk-definitions-ntt');
-require('@wormhole-foundation/sdk-solana-ntt');
+var sdkSolanaNtt = require('@wormhole-foundation/sdk-solana-ntt');
 var sdkEvm = require('@wormhole-foundation/sdk-evm');
-require('@wormhole-foundation/sdk-solana');
+var sdkSolana = require('@wormhole-foundation/sdk-solana');
 var sdkRouteNtt = require('@wormhole-foundation/sdk-route-ntt');
 var ethers = require('ethers');
+var web3_js = require('@solana/web3.js');
+var splToken = require('@solana/spl-token');
+var BN = require('bn.js');
+var sha2 = require('@noble/hashes/sha2');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var BN__default = /*#__PURE__*/_interopDefault(BN);
 
 // src/m0AutomaticRoute.ts
-var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.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 {
-      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"
+      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: splToken.TOKEN_2022_PROGRAM_ID
+        },
+        usdkbee86pkLyRmxfFCdkyySpxRb5ndCxVsK2BkRXwX: {
+          program: pk("extaykYu5AQcDm3qZAbiDN3yp6skqn6Nssj7veUUGZw"),
+          tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
+        },
+        usdkyPPxgV7sfNyKb8eDz66ogPrkRXG3wS2FVb6LLUf: {
+          program: pk("extMahs9bUFMYcviKCvnSRaXgs5PcqmMzcnHRtTqE85"),
+          tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
+        }
+      },
+      Testnet: {
+        mzeroXDoBpRVhnEXBra27qzAMdxgpWVY3DzQW7xMVJp: {
+          program: pk("wMXX1K1nca5W4pZr1piETe78gcAVVrEFi9f4g46uXko"),
+          tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
+        },
+        usdkbee86pkLyRmxfFCdkyySpxRb5ndCxVsK2BkRXwX: {
+          program: pk("Fb2AsCKmPd4gKhabT6KsremSHMrJ8G2Mopnc6rDQZX9e"),
+          tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
+        },
+        usdkyPPxgV7sfNyKb8eDz66ogPrkRXG3wS2FVb6LLUf: {
+          program: pk("3PskKTHgboCbUSQPMcCAZdZNFHbNvSoZ8zEFYANCdob7"),
+          tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
+        }
+      }
+    }[network];
+  }
+  static getSolanaContracts(chainContext) {
+    const programs = _SolanaRoutes.getPrograms(
+      chainContext.network
+    );
+    const extPrograms = _SolanaRoutes.getExtPrograms(
+      chainContext.network
+    );
+    return {
+      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 web3_js.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: splToken.getAssociatedTokenAddressSync(
+            this.programs.mMint,
+            web3_js.PublicKey.findProgramAddressSync(
+              [Buffer.from("token_authority")],
+              this.ntt.program.programId
+            )[0],
+            true,
+            splToken.TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // m token program
+          pubkey: splToken.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: web3_js.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__default.default(amount2),
+            recipientChain: {
+              id: 2
+              // Ethereum
+            },
+            recipientAddress: [...Array(32)],
+            shouldQueue: false
+          }),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // token auth
+          pubkey: web3_js.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: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.swap
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // m global
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.earn
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext global
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext token account
+          pubkey: splToken.getAssociatedTokenAddressSync(
+            extMint,
+            payer,
+            true,
+            extTokenProgram
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault
+          pubkey: splToken.getAssociatedTokenAddressSync(
+            this.programs.mMint,
+            web3_js.PublicKey.findProgramAddressSync(
+              [Buffer.from("m_vault")],
+              extProgram
+            )[0],
+            true,
+            splToken.TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault auth
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("m_vault")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint auth
+          pubkey: web3_js.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(sha2.sha256("global:transfer_extension_burn").subarray(0, 8)),
+        new BN__default.default(amount2).toArrayLike(Buffer, "le", 8),
+        // amount
+        new BN__default.default(sdkConnect.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 web3_js.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: splToken.getAssociatedTokenAddressSync(
+            this.ntt.config.mint,
+            web3_js.PublicKey.findProgramAddressSync(
+              [Buffer.from("token_authority")],
+              this.ntt.program.programId
+            )[0],
+            true,
+            splToken.TOKEN_2022_PROGRAM_ID
+          ),
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // token auth
+          pubkey: web3_js.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: splToken.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: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.earn
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint
+          pubkey: extMint,
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // swap global
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            this.programs.swap
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext global
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("global")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: true
+        },
+        {
+          // ext m vault auth
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("m_vault")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext mint auth
+          pubkey: web3_js.PublicKey.findProgramAddressSync(
+            [Buffer.from("mint_authority")],
+            extProgram
+          )[0],
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          // ext m vault
+          pubkey: splToken.getAssociatedTokenAddressSync(
+            this.ntt.config.mint,
+            web3_js.PublicKey.findProgramAddressSync(
+              [Buffer.from("m_vault")],
+              extProgram
+            )[0],
+            true,
+            splToken.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: web3_js.SystemProgram.programId,
+          isSigner: false,
+          isWritable: false
+        }
+      ],
+      data: Buffer.concat([
+        Buffer.from(
+          sha2.sha256("global:release_inbound_mint_extension").subarray(0, 8)
+        )
+      ])
+    });
+  }
+  async getAddressLookupTableAccounts(connection) {
+    const info = await connection.getAccountInfo(this.programs.lut);
+    return new web3_js.AddressLookupTableAccount({
+      key: this.programs.lut,
+      state: web3_js.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 web3_js.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 sdkSolanaNtt.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 = splToken.getAssociatedTokenAddressSync(
+      destinationMint,
+      args.recipient,
+      true,
+      extPrograms.tokenProgram
+    );
+    const ixs = [];
+    const acctInfo = await ntt.connection.getAccountInfo(extAta);
+    if (acctInfo === null) {
+      ixs.push(
+        splToken.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 web3_js.PublicKey(address);
+}
+
+// src/m0AutomaticRoute.ts
+var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.AutomaticRoute {
   static supportedNetworks() {
     return ["Mainnet", "Testnet"];
   }
@@ -29,9 +574,15 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
   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}`);
     }
@@ -51,7 +602,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
       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}`);
     }
@@ -69,8 +622,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
       return [];
     }
     const { token: mToken, mLikeTokens } = this.getContracts(toChain);
-    const toMToken = sdkConnect.Wormhole.tokenId(toChain.chain, mToken);
-    return sdkConnect.chainToPlatform(fromChain.chain) === "Solana" ? [toMToken] : [toMToken, ...mLikeTokens.map((x) => sdkConnect.Wormhole.tokenId(toChain.chain, x))];
+    return [mToken, ...mLikeTokens].map(
+      (x) => sdkConnect.Wormhole.tokenId(toChain.chain, x)
+    );
   }
   static isProtocolSupported(chain) {
     return chain.supportsProtocol("Ntt");
@@ -165,14 +719,38 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
     const platform = sdkConnect.chainToPlatform(fromChain.chain);
     const transferAmount = sdkConnect.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 = sdkConnect.canonicalAddress(request.source.id);
     const destinationToken = sdkConnect.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 sdkConnect.signSendWait(fromChain, initXfer, signer);
     return {
       from: fromChain.chain,
@@ -232,6 +810,75 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
       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 = web3_js.Keypair.generate();
+    const payerAddress = new sdkSolana.SolanaAddress(sender).unwrap();
+    const ixs = [
+      router.getTransferExtensionBurnIx(
+        amount2,
+        recipient,
+        new web3_js.PublicKey(sender.toUint8Array()),
+        outboxItem.publicKey,
+        new web3_js.PublicKey(sourceToken),
+        sdkConnect.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 web3_js.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) / web3_js.LAMPORTS_PER_SOL,
+        Number(options.gasDropoff ?? 0n) / sdkSolanaNtt.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 web3_js.TransactionMessage({
+      payerKey: payerAddress,
+      instructions: tx.instructions,
+      recentBlockhash: (await ntt.connection.getLatestBlockhash()).blockhash
+    }).compileToV0Message(luts);
+    const vtx = new web3_js.VersionedTransaction(messageV0);
+    yield ntt.createUnsignedTx(
+      { transaction: vtx, signers: [outboxItem] },
+      "Ntt.Transfer"
+    );
+  }
   async *track(receipt, timeout) {
     const isEvmPlatform = (chain) => sdkConnect.chainToPlatform(chain) === "Evm";
     if (sdkConnect.isSourceInitiated(receipt) || sdkConnect.isSourceFinalized(receipt)) {
@@ -274,7 +921,9 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
       }
     }
     if (sdkConnect.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(
         sdkDefinitionsNtt.Ntt.messageDigest(vaa.emitterChain, payload["nttManagerPayload"])
@@ -294,8 +943,6 @@ var _M0AutomaticRoute = class _M0AutomaticRoute extends sdkConnect.routes.Automa
 _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
@@ -311,3 +958,4 @@ _M0AutomaticRoute.meta = { name: "M0AutomaticRoute", provider: "M0" };
 var M0AutomaticRoute = _M0AutomaticRoute;
 
 exports.M0AutomaticRoute = M0AutomaticRoute;
+exports.SolanaRoutes = SolanaRoutes;