refactored transceiver message parsing

Author: kev1n-peters

wormhole-connect/src/hooks/useCheckInboundQueuedTransfer.ts

@@ -10,6 +10,7 @@ import { isSignedNttMessage } from 'routes/types';
 import { isNttRoute } from 'routes';
 import RouteOperator from 'routes/operator';
 import { NttBase } from 'routes/ntt/nttBase';
+import { parseWormholeTransceiverMessage } from 'routes/ntt';
 
 const RETRY_DELAY = 15_000;
 
@@ -34,8 +35,15 @@ const useCheckInboundQueuedTransfer = () => {
     ) {
       return;
     }
-    const { toChain, recipientNttManager, transceiverMessage, fromChain } =
-      signedMessage;
+    const {
+      toChain,
+      recipientNttManager,
+      wormholeTransceiverMessage,
+      fromChain,
+    } = signedMessage;
+    const { nttManagerPayload } = parseWormholeTransceiverMessage(
+      wormholeTransceiverMessage,
+    );
     const ntt = RouteOperator.getRoute(route) as NttBase;
     let active = true;
     const fetchData = async () => {
@@ -44,7 +52,7 @@ const useCheckInboundQueuedTransfer = () => {
           const queuedTransfer = await ntt.getInboundQueuedTransfer(
             toChain,
             recipientNttManager,
-            transceiverMessage,
+            nttManagerPayload,
             fromChain,
           );
           if (active) {

wormhole-connect/src/routes/ntt/index.ts

@@ -1,7 +1,6 @@
 export * from './nttBase';
 export * from './nttManual';
 export * from './nttRelay';
-export * from './consts';
 export * from './errors';
 export * from './types';
 export * from './utils';

wormhole-connect/src/routes/ntt/nttBase.ts

@@ -37,11 +37,11 @@ import {
 } from './errors';
 import { getMessageEvm } from './platforms/evm';
 import { getMessageSolana } from './platforms/solana';
-import { WormholeTransceiverMessage } from './payloads/wormhole';
 import { NttManagerMessage } from './payloads/common';
 import { NativeTokenTransfer } from './payloads/transfers';
 import { formatGasFee } from 'routes/utils';
 import { NO_INPUT } from 'utils/style';
+import { parseWormholeTransceiverMessage } from './utils';
 
 export abstract class NttBase extends BaseRoute {
   isSupportedChain(chain: ChainName): boolean {
@@ -163,8 +163,7 @@ export abstract class NttBase extends BaseRoute {
     if (isEvmChain(sendingChain)) {
       const provider = wh.mustGetProvider(sendingChain);
       const gasPrice = await provider.getGasPrice();
-      const estSendGas = 200000;
-      return gasPrice.mul(estSendGas);
+      return gasPrice.mul(200000);
     } else if (wh.toChainName(sendingChain) === 'solana') {
       return BigNumber.from(10000);
     }
@@ -182,8 +181,7 @@ export abstract class NttBase extends BaseRoute {
     if (isEvmChain(destChain)) {
       const provider = wh.mustGetProvider(destChain);
       const gasPrice = await provider.getGasPrice();
-      const estClaimGas = 300000;
-      return gasPrice.mul(estClaimGas);
+      return gasPrice.mul(300000);
     } else if (wh.toChainName(destChain) === 'solana') {
       return BigNumber.from(65000);
     }
@@ -227,7 +225,6 @@ export abstract class NttBase extends BaseRoute {
       wh.toChainId(sendingChain),
       tokenConfig.tokenId,
     );
-    // remove any dust before sending
     const sendAmount = removeDust(parseUnits(amount, decimals), decimals);
     const shouldSkipRelayerSend = this.TYPE !== Route.NttRelay;
     return await nttManager.send(
@@ -304,37 +301,29 @@ export abstract class NttBase extends BaseRoute {
   async getInboundQueuedTransfer(
     chain: ChainName | ChainId,
     nttManagerAddress: string,
-    transceiverMessage: string,
+    message: NttManagerMessage<NativeTokenTransfer>,
     fromChain: ChainName | ChainId,
   ): Promise<InboundQueuedTransfer | undefined> {
-    const nttManagerMessage = WormholeTransceiverMessage.deserialize(
-      Buffer.from(transceiverMessage.slice(2), 'hex'),
-      (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-    ).ntt_managerPayload;
     return await getNttManager(
       chain,
       nttManagerAddress,
-    ).getInboundQueuedTransfer(fromChain, nttManagerMessage);
+    ).getInboundQueuedTransfer(fromChain, message);
   }
 
   async completeInboundQueuedTransfer(
     chain: ChainName | ChainId,
     nttManagerAddress: string,
-    transceiverMessage: string,
+    message: NttManagerMessage<NativeTokenTransfer>,
     fromChain: ChainName | ChainId,
     payer: string,
   ): Promise<string> {
-    const nttManagerMessage = WormholeTransceiverMessage.deserialize(
-      Buffer.from(transceiverMessage.slice(2), 'hex'),
-      (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-    ).ntt_managerPayload;
     const nttManager = getNttManager(chain, nttManagerAddress);
     if (await nttManager.isPaused()) {
       throw new ContractIsPausedError();
     }
     return await nttManager.completeInboundQueuedTransfer(
       fromChain,
-      nttManagerMessage,
+      message,
       payer,
     );
   }
@@ -395,21 +384,20 @@ export abstract class NttBase extends BaseRoute {
     if (!isSignedNttMessage(signedMessage)) {
       throw new Error('Invalid signed message');
     }
-    const { fromChain, recipientNttManager, transceiverMessage } =
+    const { fromChain, recipientNttManager, wormholeTransceiverMessage } =
       signedMessage;
-    const nttManagerMessage = WormholeTransceiverMessage.deserialize(
-      Buffer.from(transceiverMessage.slice(2), 'hex'),
-      (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-    ).ntt_managerPayload;
+    const { nttManagerPayload } = parseWormholeTransceiverMessage(
+      wormholeTransceiverMessage,
+    );
     const nttManager = getNttManager(chain, recipientNttManager);
     const isMessageExecuted = await nttManager.isMessageExecuted(
       fromChain,
-      nttManagerMessage,
+      nttManagerPayload,
     );
     if (isMessageExecuted) {
       const queuedTransfer = await nttManager.getInboundQueuedTransfer(
         fromChain,
-        nttManagerMessage,
+        nttManagerPayload,
       );
       return !queuedTransfer;
     }

wormhole-connect/src/routes/ntt/nttRelay.ts

@@ -21,9 +21,7 @@ import { toChainId, wh } from 'utils/sdk';
 import { NO_INPUT } from 'utils/style';
 import { TokenPrices } from 'store/tokenPrices';
 import { toDecimals, toFixedDecimals } from 'utils/balance';
-import { NttManagerMessage } from './payloads/common';
-import { NativeTokenTransfer } from './payloads/transfers';
-import { WormholeTransceiverMessage } from './payloads/wormhole';
+import { parseWormholeTransceiverMessage } from './utils';
 
 export class NttRelay extends NttBase {
   readonly NATIVE_GAS_DROPOFF_SUPPORTED: boolean = false;
@@ -190,15 +188,18 @@ export class NttRelay extends NttBase {
     if (!isUnsignedNttMessage(txData)) {
       throw new Error('invalid txData');
     }
-    const { transceiverMessage, toChain, fromChain, recipientNttManager } =
-      txData;
-    const nttManagerMessage = WormholeTransceiverMessage.deserialize(
-      Buffer.from(transceiverMessage.slice(2), 'hex'),
-      (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-    ).ntt_managerPayload;
+    const {
+      wormholeTransceiverMessage,
+      toChain,
+      fromChain,
+      recipientNttManager,
+    } = txData;
+    const { nttManagerPayload } = parseWormholeTransceiverMessage(
+      wormholeTransceiverMessage,
+    );
     const nttManager = getNttManager(toChain, recipientNttManager);
     try {
-      return await nttManager.fetchRedeemTx(fromChain, nttManagerMessage);
+      return await nttManager.fetchRedeemTx(fromChain, nttManagerPayload);
     } catch (e) {
       console.error(e);
     }

wormhole-connect/src/routes/ntt/payloads/common.ts

@@ -4,7 +4,7 @@ export class TransceiverMessage<A> {
   static prefix: Buffer;
   sourceNttManager: Buffer;
   recipientNttManager: Buffer;
-  ntt_managerPayload: NttManagerMessage<A>;
+  nttManagerPayload: NttManagerMessage<A>;
   transceiverPayload: Buffer;
 
   constructor(
@@ -15,7 +15,7 @@ export class TransceiverMessage<A> {
   ) {
     this.sourceNttManager = sourceNttManager;
     this.recipientNttManager = recipientNttManager;
-    this.ntt_managerPayload = ntt_managerPayload;
+    this.nttManagerPayload = ntt_managerPayload;
     this.transceiverPayload = transceiverPayload;
   }
 
@@ -53,7 +53,7 @@ export class TransceiverMessage<A> {
     msg: TransceiverMessage<A>,
     serializer: (payload: NttManagerMessage<A>) => Buffer,
   ): Buffer {
-    const payload = serializer(msg.ntt_managerPayload);
+    const payload = serializer(msg.nttManagerPayload);
     const payloadLen = new BN(payload.length).toBuffer('be', 2);
     const transceiverPayloadLen = new BN(
       msg.transceiverPayload.length,

wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts

@@ -14,9 +14,7 @@ import { getTokenById, getTokenDecimals } from 'utils';
 import { wh } from 'utils/sdk';
 import { getWormholeLogEvm } from 'utils/vaa';
 import { NttManager__factory } from './abis';
-import { NttManagerMessage } from '../../payloads/common';
-import { WormholeTransceiverMessage } from '../../payloads/wormhole';
-import { NativeTokenTransfer } from '../../payloads/transfers';
+import { parseWormholeTransceiverMessage } from 'routes/ntt/utils';
 
 export const getMessageEvm = async (
   tx: string,
@@ -72,11 +70,8 @@ export const getMessageEvm = async (
       relayerFee = parsed.args.deliveryQuote.toString();
     }
   }
-  const transceiverMessage = WormholeTransceiverMessage.deserialize(
-    payload,
-    (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-  );
-  const nttManagerMessage = transceiverMessage.ntt_managerPayload;
+  const transceiverMessage = parseWormholeTransceiverMessage(payload);
+  const nttManagerMessage = transceiverMessage.nttManagerPayload;
   const toChain = wh.toChainName(nttManagerMessage.payload.recipientChain);
   const receivedTokenKey = getNativeVersionOfToken(token.symbol, toChain);
   const destToken = TOKENS[receivedTokenKey];
@@ -113,7 +108,7 @@ export const getMessageEvm = async (
       transceiverMessage.recipientNttManager,
       toChain,
     ),
-    transceiverMessage: hexlify(payload),
+    wormholeTransceiverMessage: hexlify(payload),
     relayerFee,
   };
 };

wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts

@@ -6,9 +6,7 @@ import { getNativeVersionOfToken } from 'store/transferInput';
 import { getTokenById, getTokenDecimals } from 'utils';
 import { wh } from 'utils/sdk';
 import { TokenId } from '@wormhole-foundation/wormhole-connect-sdk';
-import { WormholeTransceiverMessage } from '../../payloads/wormhole';
-import { NttManagerMessage } from '../../payloads/common';
-import { NativeTokenTransfer } from '../../payloads/transfers';
+import { parseWormholeTransceiverMessage } from 'routes/ntt/utils';
 
 export const getMessageSolana = async (
   tx: string,
@@ -37,11 +35,10 @@ export const getMessageSolana = async (
   const messageData = PostedMessageData.deserialize(
     wormholeMessageAccount.data,
   );
-  const transceiverMessage = WormholeTransceiverMessage.deserialize(
+  const transceiverMessage = parseWormholeTransceiverMessage(
     messageData.message.payload,
-    (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
   );
-  const nttManagerMessage = transceiverMessage.ntt_managerPayload;
+  const nttManagerMessage = transceiverMessage.nttManagerPayload;
   const fromChain = wh.toChainName('solana');
   const toChain = wh.toChainName(nttManagerMessage.payload.recipientChain);
   const tokenAddress = wh.parseAddress(
@@ -86,7 +83,7 @@ export const getMessageSolana = async (
       hexlify(transceiverMessage.recipientNttManager),
       toChain,
     ),
-    transceiverMessage: hexlify(messageData.message.payload),
+    wormholeTransceiverMessage: hexlify(messageData.message.payload),
     relayerFee: '',
   };
 };

wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts

@@ -16,9 +16,9 @@ import {
 import { BN } from '@coral-xyz/anchor';
 import { parseVaa } from '@certusone/wormhole-sdk/lib/esm';
 import { utils } from 'ethers';
-import { WormholeTransceiverMessage } from '../../payloads/wormhole';
 import { NttManagerMessage } from '../../payloads/common';
 import { NativeTokenTransfer } from '../../payloads/transfers';
+import { parseWormholeTransceiverMessage } from 'routes/ntt/utils';
 
 // TODO: make sure this is in sync with the contract
 const RATE_LIMIT_DURATION = 24 * 60 * 60;
@@ -76,9 +76,6 @@ export class NttManagerSolana {
       new PublicKey(token.address),
       payer,
     );
-    // TODO: make sure limits change
-    const limit = await this.getCurrentOutboundCapacity();
-    console.log('limit', limit);
     const txArgs = {
       payer,
       from: tokenAccount,
@@ -168,14 +165,13 @@ export class NttManagerSolana {
     // just make the second instruction a no-op in case the transfer is delayed.
     tx.add(await this.ntt.createReceiveWormholeMessageInstruction(redeemArgs));
     tx.add(await this.ntt.createRedeemInstruction(redeemArgs));
-    const nttManagerMessage = WormholeTransceiverMessage.deserialize(
+    const { nttManagerPayload } = parseWormholeTransceiverMessage(
       parsedVaa.payload,
-      (a) => NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize),
-    ).ntt_managerPayload;
+    );
     const releaseArgs = {
       ...redeemArgs,
-      ntt_managerMessage: nttManagerMessage,
-      recipient: new PublicKey(nttManagerMessage.payload.recipientAddress),
+      ntt_managerMessage: nttManagerPayload,
+      recipient: new PublicKey(nttManagerPayload.payload.recipientAddress),
       chain: chainId,
       revertOnDelay: false,
     };
@@ -247,11 +243,11 @@ export class NttManagerSolana {
 
   async getInboundQueuedTransfer(
     emitterChain: ChainName | ChainId,
-    managerMessage: NttManagerMessage<NativeTokenTransfer>,
+    message: NttManagerMessage<NativeTokenTransfer>,
   ): Promise<InboundQueuedTransfer | undefined> {
     let inboxItem;
     try {
-      inboxItem = await this.ntt.getInboxItem(emitterChain, managerMessage);
+      inboxItem = await this.ntt.getInboxItem(emitterChain, message);
     } catch (e: any) {
       if (e.message?.includes('Account does not exist')) {
         return undefined;
@@ -271,14 +267,14 @@ export class NttManagerSolana {
 
   async completeInboundQueuedTransfer(
     emitterChain: ChainName | ChainId,
-    nttManagerMessage: NttManagerMessage<NativeTokenTransfer>,
+    message: NttManagerMessage<NativeTokenTransfer>,
     payer: string,
   ): Promise<string> {
     const payerPublicKey = new PublicKey(payer);
     const releaseArgs = {
       payer: payerPublicKey,
-      ntt_managerMessage: nttManagerMessage,
-      recipient: new PublicKey(nttManagerMessage.payload.recipientAddress),
+      ntt_managerMessage: message,
+      recipient: new PublicKey(message.payload.recipientAddress),
       chain: emitterChain,
       revertOnDelay: false,
     };
@@ -315,13 +311,10 @@ export class NttManagerSolana {
 
   async isMessageExecuted(
     emitterChain: ChainName | ChainId,
-    nttManagerMessage: NttManagerMessage<NativeTokenTransfer>,
+    message: NttManagerMessage<NativeTokenTransfer>,
   ): Promise<boolean> {
     try {
-      const inboxItem = await this.ntt.getInboxItem(
-        emitterChain,
-        nttManagerMessage,
-      );
+      const inboxItem = await this.ntt.getInboxItem(emitterChain, message);
       return (
         inboxItem.releaseStatus.released !== null &&
         inboxItem.releaseStatus.released !== undefined
@@ -340,11 +333,11 @@ export class NttManagerSolana {
 
   async fetchRedeemTx(
     emitterChain: ChainName | ChainId,
-    nttManagerMessage: NttManagerMessage<NativeTokenTransfer>,
+    message: NttManagerMessage<NativeTokenTransfer>,
   ): Promise<string | undefined> {
     const address = await this.ntt.inboxItemAccountAddress(
       emitterChain,
-      nttManagerMessage,
+      message,
     );
     // fetch the most recent signature
     const signatures = await this.connection.getSignaturesForAddress(address, {