chore: refactor more

Author: kev1n-peters

foo.sh

@@ -264,7 +264,7 @@ export interface Ntt<N extends Network, C extends Chain> {
    * redeem redeems a set of Attestations to the corresponding transceivers on the destination chain
    * @param attestations The attestations to redeem, the length should be equal to the number of transceivers
    * @param payer The account that will pay for the transaction
-   * @param recipient The recipient address (only used for Stacks, can be undefined for other platforms)
+   * @param recipient The recipient address
    *
    * TODO: replace with Map<transceiver type, Attestation>
    */

sdk/definitions/src/ntt.ts

@@ -283,7 +283,7 @@ export class NttAutomaticRoute<N extends Network>
             address: vaa.emitterAddress,
           });
 
-    const dstInfo = NttRoute.resolveDestinationNttContracts(
+    const { dstContracts: dstInfo } = NttRoute.resolveDestinationNttContracts(
       this.staticConfig,
       {
         chain: vaa.emitterChain,

sdk/route/src/automatic.ts

@@ -42,10 +42,11 @@ import {
   fetchCapabilities,
   fetchSignedQuote,
   fetchStatus,
-  isRelayStatusFailed,
   getNativeRecipientAddress,
+  isRelayStatusFailed,
 } from "./utils.js";
 import { Ntt, NttWithExecutor } from "@wormhole-foundation/sdk-definitions-ntt";
+import { StacksNttWithExecutor } from "@wormhole-foundation/sdk-stacks-ntt";
 import {
   isNative,
   relayInstructionsLayout,
@@ -404,7 +405,6 @@ export class NttExecutorRoute<N extends Network>
         request: {
           type: "StacksNttReceiveInstruction" as const,
           nttManager: Buffer.from(
-            // TODO: is using Buffer correct?
             params.normalizedParams.destinationContracts.manager
           ),
           recipient: recipient
@@ -617,50 +617,26 @@ export class NttExecutorRoute<N extends Network>
     const { recipientChain, trimmedAmount } =
       vaa.payload["nttManagerPayload"].payload;
 
-    let token: string, manager: string, whTransceiver: string;
-    let dstInfo: Ntt.Contracts;
-
-    if (chainToPlatform(vaa.emitterChain) === "Stacks") {
-      const { stacksConfig, dstInfo: stacksDstInfo } =
-        NttRoute.resolveDestinationNttContractsStacksEmitter(
-          this.staticConfig.ntt,
-          vaa.emitterAddress,
-          recipientChain
-        );
-
-      token = stacksConfig.token;
-      manager = stacksConfig.manager;
-      whTransceiver = stacksConfig.transceiver.find(
-        (t) => t.type === "wormhole"
-      )!.address;
-
-      dstInfo = stacksDstInfo;
-    } else {
-      token = canonicalAddress({
-        chain: vaa.emitterChain,
-        address: vaa.payload["nttManagerPayload"].payload.sourceToken,
-      });
-      manager = canonicalAddress({
+    const srcManagerAddress = await (async () => {
+      if (chainToPlatform(tx.chain) === "Stacks") {
+        // We can't use the manager address from the VAA payload for Stacks
+        // since it's the hashed address. Instead, we need to fetch it from the transaction.
+        const stacks = this.wh.getChain("Stacks");
+        const rpc = await stacks.getRpc();
+        return StacksNttWithExecutor.getManagerAddressFromTx(rpc, tx.txid);
+      }
+      return {
         chain: vaa.emitterChain,
         address: vaa.payload["sourceNttManager"],
-      });
-      whTransceiver =
-        chainToPlatform(vaa.emitterChain) === "Solana"
-          ? manager
-          : canonicalAddress({
-              chain: vaa.emitterChain,
-              address: vaa.emitterAddress,
-            });
-
-      dstInfo = NttRoute.resolveDestinationNttContracts(
+      };
+    })();
+
+    const { srcContracts, dstContracts } =
+      NttRoute.resolveDestinationNttContracts(
         this.staticConfig.ntt,
-        {
-          chain: vaa.emitterChain,
-          address: vaa.payload["sourceNttManager"],
-        },
+        srcManagerAddress,
         recipientChain
       );
-    }
 
     const amt = amount.fromBaseUnits(
       trimmedAmount.amount,
@@ -681,20 +657,8 @@ export class NttExecutorRoute<N extends Network>
         options: {},
         normalizedParams: {
           amount: amt,
-          sourceContracts: {
-            token,
-            manager,
-            transceiver: {
-              wormhole: whTransceiver,
-            },
-          },
-          destinationContracts: {
-            token: dstInfo.token,
-            manager: dstInfo.manager,
-            transceiver: {
-              wormhole: dstInfo.transceiver["wormhole"]!,
-            },
-          },
+          sourceContracts: srcContracts,
+          destinationContracts: dstContracts,
           referrerFeeDbps: 0n,
         },
       },

sdk/route/src/executor/executor.ts

@@ -264,7 +264,7 @@ export class NttManualRoute<N extends Network>
             address: vaa.emitterAddress,
           });
 
-    const dstInfo = NttRoute.resolveDestinationNttContracts(
+    const { dstContracts: dstInfo } = NttRoute.resolveDestinationNttContracts(
       this.staticConfig,
       {
         chain: vaa.emitterChain,

sdk/route/src/manual.ts

@@ -15,7 +15,6 @@ import {
   TransferReceipt as _TransferReceipt,
   amount,
   canonicalAddress,
-  encoding,
   isAttested,
   isCompleted,
   isDestinationQueued,
@@ -31,10 +30,6 @@ import {
   toUniversal,
 } from "@wormhole-foundation/sdk-connect";
 import { MultiTokenNtt, Ntt } from "@wormhole-foundation/sdk-definitions-ntt";
-import {
-  keccak256,
-  UniversalAddress,
-} from "@wormhole-foundation/sdk-definitions";
 import { trackAxelar, trackExecutor } from "./tracking.js";
 
 export namespace NttRoute {
@@ -244,7 +239,7 @@ export namespace NttRoute {
     config: Config,
     srcManager: ChainAddress<C>,
     dstChain: Chain
-  ): Ntt.Contracts {
+  ): { srcContracts: Ntt.Contracts; dstContracts: Ntt.Contracts } {
     const cfg = Object.values(config.tokens);
     const address = canonicalAddress(srcManager);
     for (const tokens of cfg) {
@@ -260,7 +255,19 @@ export namespace NttRoute {
             `Cannot find destination Ntt contracts in config for: ${address}`
           );
         }
-        return {
+
+        const srcContracts = {
+          token: found.token,
+          manager: found.manager,
+          transceiver: {
+            wormhole: found.transceiver.find((v) => v.type === "wormhole")!
+              .address,
+          },
+          quoter: found.quoter,
+          svmShims: found.svmShims,
+        };
+
+        const dstContracts = {
           token: remote.unwrapsOnRedeem ? "native" : remote.token,
           manager: remote.manager,
           transceiver: {
@@ -270,61 +277,11 @@ export namespace NttRoute {
           quoter: remote.quoter,
           svmShims: remote.svmShims,
         };
-      }
-    }
-    throw new Error("Cannot find Ntt contracts in config for: " + address);
-  }
-
-  export function resolveDestinationNttContractsStacksEmitter(
-    config: Config,
-    emitterAddress: UniversalAddress,
-    dstChain: Chain
-  ): { stacksConfig: TokenConfig; dstInfo: Ntt.Contracts } {
-    const emitterLower = emitterAddress.toString().toLowerCase();
-
-    for (const tokens of Object.values(config.tokens)) {
-      for (const tokenConfig of tokens) {
-        if (tokenConfig.chain === "Stacks") {
-          const whTransceiver = tokenConfig.transceiver.find(
-            (t) => t.type === "wormhole"
-          );
-          if (whTransceiver) {
-            // The emitter address on the VAA is the keccak256 hash of the transceiver address
-            const hash = keccak256(whTransceiver.address);
-            const hashHex = encoding.hex
-              .encode(hash, true)
-              .toString()
-              .toLowerCase();
-            if (hashHex === emitterLower) {
-              // Find the destination config in the same token group
-              const remote = tokens.find((tc) => tc.chain === dstChain);
-              if (!remote) {
-                throw new Error(
-                  `Cannot find destination Ntt contracts in config for chain: ${dstChain}`
-                );
-              }
 
-              const dstInfo: Ntt.Contracts = {
-                token: remote.unwrapsOnRedeem ? "native" : remote.token,
-                manager: remote.manager,
-                transceiver: {
-                  wormhole: remote.transceiver.find(
-                    (v) => v.type === "wormhole"
-                  )!.address,
-                },
-                quoter: remote.quoter,
-                svmShims: remote.svmShims,
-              };
-
-              return { stacksConfig: tokenConfig, dstInfo };
-            }
-          }
-        }
+        return { srcContracts, dstContracts };
       }
     }
-    throw new Error(
-      `Cannot find Stacks NTT config for emitter: ${emitterAddress}`
-    );
+    throw new Error("Cannot find Ntt contracts in config for: " + address);
   }
 
   // returns true if the amount is greater than 95% of the capacity

sdk/route/src/types.ts

@@ -9,6 +9,7 @@ import {
 } from "@wormhole-foundation/sdk-definitions";
 import { NttWithExecutor } from "@wormhole-foundation/sdk-definitions-ntt";
 import {
+  StacksAddress,
   StacksChains,
   StacksPlatform,
   StacksUnsignedTransaction,
@@ -23,6 +24,7 @@ import {
   standardPrincipalCV,
   uintCV,
 } from "@stacks/transactions";
+import axios from "axios";
 import { StacksNtt, StacksNttContracts } from "./ntt.js";
 
 const nttManagerWithExecutorAddresses: Partial<
@@ -115,7 +117,6 @@ export class StacksNttWithExecutor<N extends Network, C extends StacksChains>
 
     const referrerAddress = quote.referrer.address.toString();
 
-    // TODO: ContractCallOptions should be the UnisgnedTransactionType
     const tx: ContractCallOptions = {
       contractName: executorContractName,
       contractAddress: executorDeployer,
@@ -157,4 +158,32 @@ export class StacksNttWithExecutor<N extends Network, C extends StacksChains>
 
     return { msgValue, gasLimit };
   }
+
+  static async getManagerAddressFromTx(
+    connection: StacksNetwork,
+    txHash: string
+  ): Promise<ChainAddress<"Stacks">> {
+    const url = `${connection.client.baseUrl}/extended/v1/tx/${txHash}`;
+
+    const response = await axios.get(url);
+    const data = response.data;
+
+    if (!data.contract_call?.function_args) {
+      throw new Error("No contract call function args found in transaction");
+    }
+
+    const functionArgs = data.contract_call.function_args;
+    const nttManagerArg = functionArgs.find(
+      (arg: any) => arg.name === "ntt-manager"
+    );
+
+    if (!nttManagerArg) {
+      throw new Error("No ntt-manager argument found in transaction");
+    }
+
+    // For some reason, the value comes with extra single quotes, so we need to remove them
+    const managerAddress = nttManagerArg.repr.replace(/'/g, "");
+
+    return { chain: "Stacks", address: new StacksAddress(managerAddress) };
+  }
 }