@townsq/mm-sdk 1.0.1

package/src/chains/evm/spoke/modules/ts-evm-account.ts

@@ -0,0 +1,341 @@
+import { GAS_LIMIT_ESTIMATE_INCREASE } from '../../common/constant/contract.js';
+import { getEvmSignerAccount } from '../../common/utils/chain.js';
+import {
+  getSpokeMessageDispatcherContract,
+  getSpokeOperationContract,
+} from '../utils/contract.js';
+
+import type {
+  EvmAddress,
+  GenericAddress,
+} from '../../../../common/types/address.js';
+import type { TSChainId, SpokeChain } from '../../../../common/types/chain.js';
+import type { AccountId, Nonce } from '../../../../common/types/lending.js';
+import type { MessageToSend } from '../../../../common/types/message.js';
+import type {
+  PrepareAcceptInviteAddressCall,
+  PrepareCreateAccountCall,
+  PrepareInviteAddressCall,
+  PrepareUnregisterAddressCall,
+} from '../../common/types/module.js';
+import type { Client, EstimateGasParameters, WalletClient } from 'viem';
+
+export const prepare = {
+  async createAccount(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    nonce: Nonce,
+    refAccountId: AccountId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareCreateAccountCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.createAccount(
+      [messageToSend.params, accountId, nonce, refAccountId],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      accountId,
+      spokeOperationAddress,
+    };
+  },
+
+  async inviteAddress(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    tsChainIdToInvite: number,
+    addressToInvite: GenericAddress,
+    refAccountId: AccountId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareInviteAddressCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.inviteAddress(
+      [
+        messageToSend.params,
+        accountId,
+        tsChainIdToInvite,
+        addressToInvite,
+        refAccountId,
+      ],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async acceptInvite(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareAcceptInviteAddressCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.acceptInviteAddress(
+      [messageToSend.params, accountId],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+
+  async unregisterAddress(
+    provider: Client,
+    sender: EvmAddress,
+    messageToSend: MessageToSend,
+    accountId: AccountId,
+    tsChainIdToUnregister: TSChainId,
+    spokeChain: SpokeChain,
+    transactionOptions: EstimateGasParameters = { account: sender }
+  ): Promise<PrepareUnregisterAddressCall> {
+    const spokeOperationAddress = spokeChain.spokeOperationAddress;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress
+    );
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      spokeChain.messageDispatcherAddress
+    );
+
+    // get adapter fees
+    const msgValue = await bridgeRouter.read.getSendFee([messageToSend]);
+    // get gas limits
+    const gasLimit = await spokeOperation.estimateGas.unregisterAddress(
+      [messageToSend.params, accountId, tsChainIdToUnregister],
+      {
+        value: msgValue,
+        ...transactionOptions,
+      }
+    );
+
+    return {
+      msgValue,
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      messageParams: messageToSend.params,
+      spokeOperationAddress,
+    };
+  },
+};
+
+export const write = {
+  async createAccount(
+    provider: Client,
+    signer: WalletClient,
+    nonce: Nonce,
+    refAccountId: AccountId,
+    prepareCall: PrepareCreateAccountCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      accountId,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.createAccount(
+      [messageParams, accountId, nonce, refAccountId],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async inviteAddress(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    tsChainIdToInvite: TSChainId,
+    addressToInvite: GenericAddress,
+    refAccountId: AccountId,
+    prepareCall: PrepareInviteAddressCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.inviteAddress(
+      [
+        messageParams,
+        accountId,
+        tsChainIdToInvite,
+        addressToInvite,
+        refAccountId,
+      ],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async acceptInvite(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    prepareCall: PrepareAcceptInviteAddressCall
+  ) {
+    const {
+      msgValue,
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.acceptInviteAddress(
+      [messageParams, accountId],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async unregisterAddress(
+    provider: Client,
+    signer: WalletClient,
+    accountId: AccountId,
+    tsChainIdToUnregister: TSChainId,
+    prepareCall: PrepareUnregisterAddressCall
+  ) {
+    const {
+      msgValue,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      gasLimit,
+      messageParams,
+      spokeOperationAddress,
+    } = prepareCall;
+
+    const spokeOperation = getSpokeOperationContract(
+      provider,
+      spokeOperationAddress,
+      signer
+    );
+
+    return await spokeOperation.write.unregisterAddress(
+      [messageParams, accountId, tsChainIdToUnregister],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+};

package/src/chains/evm/spoke/modules/ts-evm-gmp.ts

@@ -0,0 +1,353 @@
+import { FINALITY } from '../../../../common/constants/message.js';
+import { ChainType } from '../../../../common/types/chain.js';
+import {
+  convertFromGenericAddress,
+  convertToGenericAddress,
+  getRandomGenericAddress,
+} from '../../../../common/utils/address.js';
+import { getRandomBytes } from '../../../../common/utils/bytes.js';
+import { getSpokeChainBridgeRouterAddress } from '../../../../common/utils/chain.js';
+import { getWormholeData } from '../../../../common/utils/gmp.js';
+import { GAS_LIMIT_ESTIMATE_INCREASE } from '../../common/constant/contract.js';
+import { getEvmSignerAccount } from '../../common/utils/chain.js';
+import { getWormholeRelayerContract } from '../../common/utils/contract.js';
+import {
+  buildMessageParams,
+  buildSendTokenExtraArgsWhenAdding,
+} from '../../common/utils/message.js';
+import { getSpokeMessageDispatcherContract } from '../utils/contract.js';
+
+import type {
+  EvmAddress,
+  GenericAddress,
+} from '../../../../common/types/address.js';
+import type { TSChainId, SpokeChain } from '../../../../common/types/chain.js';
+import type { MessageId } from '../../../../common/types/gmp.js';
+import type {
+  AdapterType,
+  MessageToSend,
+} from '../../../../common/types/message.js';
+import type { SpokeTokenData } from '../../../../common/types/token.js';
+import type { MessageReceived } from '../../common/types/gmp.js';
+import type {
+  PrepareResendWormholeMessageCall,
+  PrepareRetryMessageCall,
+  PrepareReverseMessageCall,
+} from '../../common/types/module.js';
+import type { HubChain } from '../../hub/types/chain.js';
+import type { Client, EstimateGasParameters, Hex, WalletClient } from 'viem';
+
+export const prepare = {
+  async retryMessage(
+    provider: Client,
+    sender: EvmAddress,
+    adapterId: AdapterType,
+    messageId: MessageId,
+    message: MessageReceived,
+    extraArgs: Hex,
+    value: bigint,
+    spokeChain: SpokeChain,
+    isRewards = false,
+    transactionOptions: EstimateGasParameters = {
+      account: sender,
+    }
+  ): Promise<PrepareRetryMessageCall> {
+    const bridgeRouterAddress = getSpokeChainBridgeRouterAddress(spokeChain);
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      bridgeRouterAddress
+    );
+
+    const gasLimit = await bridgeRouter.estimateGas.retryMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        ...transactionOptions,
+        value,
+      }
+    );
+
+    return {
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      msgValue: value,
+      isHub: false,
+      message,
+      extraArgs,
+      bridgeRouterAddress: spokeChain.messageDispatcherAddress,
+    };
+  },
+
+  async reverseMessage(
+    provider: Client,
+    sender: EvmAddress,
+    adapterId: AdapterType,
+    messageId: MessageId,
+    message: MessageReceived,
+    extraArgs: Hex,
+    value: bigint,
+    spokeChain: SpokeChain,
+    isRewards = false,
+    transactionOptions: EstimateGasParameters = {
+      account: sender,
+    }
+  ): Promise<PrepareRetryMessageCall> {
+    const bridgeRouterAddress = getSpokeChainBridgeRouterAddress(spokeChain);
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      bridgeRouterAddress
+    );
+
+    const gasLimit = await bridgeRouter.estimateGas.reverseMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        ...transactionOptions,
+        value,
+      }
+    );
+
+    return {
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      msgValue: value,
+      isHub: false,
+      message,
+      extraArgs,
+      bridgeRouterAddress: spokeChain.messageDispatcherAddress,
+    };
+  },
+
+  async resendWormholeMessage(
+    provider: Client,
+    sender: EvmAddress,
+    sourceTSChainId: TSChainId,
+    emitterAddress: GenericAddress,
+    sequence: bigint,
+    targetTSChainId: TSChainId,
+    receiverValue: bigint,
+    receiverGasLimit: bigint,
+    transactionOptions: EstimateGasParameters = {
+      account: sender,
+    }
+  ): Promise<PrepareResendWormholeMessageCall> {
+    const {
+      wormholeChainId: sourceWormholeChainId,
+      wormholeRelayer: wormholeRelayerAddress,
+    } = getWormholeData(sourceTSChainId);
+    const wormholeRelayer = getWormholeRelayerContract(
+      provider,
+      wormholeRelayerAddress
+    );
+    const { wormholeChainId: targetWormholeChainId } =
+      getWormholeData(targetTSChainId);
+
+    // get delivery provider address
+    const evmDeliveryProviderAddress =
+      (await wormholeRelayer.read.getDefaultDeliveryProvider()) as EvmAddress;
+    const genericDeliveryProviderAddress = convertToGenericAddress(
+      evmDeliveryProviderAddress,
+      ChainType.EVM
+    );
+
+    // get quote for delivery
+    const [value] = (await wormholeRelayer.read.quoteEVMDeliveryPrice([
+      targetWormholeChainId,
+      receiverValue,
+      receiverGasLimit,
+      evmDeliveryProviderAddress,
+    ])) as [bigint, bigint];
+
+    // estimate gas limit
+    const vaaKey = {
+      chainId: sourceWormholeChainId,
+      emitterAddress,
+      sequence,
+    };
+    const gasLimit = await wormholeRelayer.estimateGas.resendToEvm(
+      [
+        vaaKey,
+        targetWormholeChainId,
+        receiverValue,
+        receiverGasLimit,
+        evmDeliveryProviderAddress,
+      ],
+      {
+        ...transactionOptions,
+        value,
+      }
+    );
+
+    return {
+      gasLimit: gasLimit + GAS_LIMIT_ESTIMATE_INCREASE,
+      msgValue: value,
+      vaaKey,
+      targetWormholeChainId,
+      receiverValue,
+      receiverGasLimit,
+      deliveryProviderAddress: genericDeliveryProviderAddress,
+      wormholeRelayerAddress,
+    };
+  },
+};
+
+export const write = {
+  async retryMessage(
+    provider: Client,
+    signer: WalletClient,
+    adapterId: AdapterType,
+    messageId: MessageId,
+    prepareCall: PrepareRetryMessageCall
+  ) {
+    const {
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      msgValue,
+      message,
+      extraArgs,
+      bridgeRouterAddress,
+    } = prepareCall;
+
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      bridgeRouterAddress,
+      signer
+    );
+
+    return await bridgeRouter.write.retryMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async reverseMessage(
+    provider: Client,
+    signer: WalletClient,
+    adapterId: AdapterType,
+    messageId: MessageId,
+    prepareCall: PrepareReverseMessageCall
+  ) {
+    const {
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      msgValue,
+      message,
+      extraArgs,
+      bridgeRouterAddress,
+    } = prepareCall;
+
+    const bridgeRouter = getSpokeMessageDispatcherContract(
+      provider,
+      bridgeRouterAddress,
+      signer
+    );
+
+    return await bridgeRouter.write.reverseMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+
+  async resendMessage(
+    provider: Client,
+    signer: WalletClient,
+    prepareCall: PrepareResendWormholeMessageCall
+  ) {
+    const {
+      gasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      msgValue,
+      vaaKey,
+      targetWormholeChainId,
+      receiverValue,
+      receiverGasLimit,
+      deliveryProviderAddress,
+      wormholeRelayerAddress,
+    } = prepareCall;
+
+    const evmDeliveryProviderAddress = convertFromGenericAddress(
+      deliveryProviderAddress,
+      ChainType.EVM
+    );
+    const wormholeRelayer = getWormholeRelayerContract(
+      provider,
+      wormholeRelayerAddress,
+      signer
+    );
+
+    return await wormholeRelayer.write.resendToEvm(
+      [
+        vaaKey,
+        targetWormholeChainId,
+        receiverValue,
+        receiverGasLimit,
+        evmDeliveryProviderAddress,
+      ],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+};
+
+export async function getSendMessageFee(
+  provider: Client,
+  adapterId: AdapterType,
+  receiverValue: bigint,
+  gasLimit: bigint,
+  hubChain: HubChain,
+  spokeChain: SpokeChain,
+  spokeTokenData?: SpokeTokenData,
+  isRewards = false
+): Promise<bigint> {
+  const bridgeRouterAddress = getSpokeChainBridgeRouterAddress(spokeChain);
+  const bridgeRouter = getSpokeMessageDispatcherContract(
+    provider,
+    bridgeRouterAddress
+  );
+
+  // construct return message
+  const message: MessageToSend = {
+    params: buildMessageParams({
+      adapters: {
+        adapterId,
+        returnAdapterId: 0 as AdapterType,
+      },
+      gasLimit,
+      receiverValue,
+    }),
+    sender: spokeChain.spokeOperationAddress,
+    destinationChainId: hubChain.tsChainId,
+    handler: getRandomGenericAddress(),
+    payload: getRandomBytes(256),
+    finalityLevel: FINALITY.FINALISED,
+    extraArgs: spokeTokenData
+      ? buildSendTokenExtraArgsWhenAdding(
+          getRandomGenericAddress(),
+          spokeTokenData.token,
+          1n
+        )
+      : '0x',
+  };
+
+  // get return adapter fee
+  return await bridgeRouter.read.getSendFee([message]);
+}