@townsq/mm-sdk 1.0.1

package/src/chains/evm/hub/constants/chain.ts

@@ -0,0 +1,305 @@
+import { TS_CHAIN_ID } from '../../../../common/constants/chain.js';
+import { MAINNET_POOLS } from '../../../../common/constants/pool.js';
+import { ChainType, NetworkType } from '../../../../common/types/chain.js';
+import { MAINNET_LOAN_TYPE_ID } from '../../../../common/types/lending.js';
+import { AdapterType } from '../../../../common/types/message.js';
+import {
+  MAINNET_TS_TOKEN_ID,
+  TokenType,
+} from '../../../../common/types/token.js';
+import { convertToGenericAddress } from '../../../../common/utils/address.js';
+
+import type { EvmAddress } from '../../../../common/types/address.js';
+import type { MainnetTsTokenId } from '../../../../common/types/token.js';
+import type { HubChain } from '../types/chain.js';
+import type { NodeId } from '../types/oracle.js';
+import type { HubTokenData } from '../types/token.js';
+
+export const HUB_CHAIN: Record<NetworkType.MAINNET, HubChain> = {
+  [NetworkType.MAINNET]: {
+    tsChainId: TS_CHAIN_ID.MONAD,
+    hubAddress: convertToGenericAddress(
+      '0x2dfdb4bf6c910b5bbbb0d07ec5f088e294628189' as EvmAddress,
+      ChainType.EVM
+    ),
+    hubMessageDispatcher: convertToGenericAddress(
+      '0xed84c02a0787d56d0b53efe64dd60a1ae20e4e31' as EvmAddress,
+      ChainType.EVM
+    ),
+    adapters: {
+      [AdapterType.HUB]: convertToGenericAddress(
+        '0x2970fde6064178d51d961689cb5b64226ab11fc2' as EvmAddress,
+        ChainType.EVM
+      ),
+      // [AdapterType.WORMHOLE_DATA]: convertToGenericAddress(
+      //   '' as EvmAddress,
+      //   ChainType.EVM
+      // ),
+    },
+    nodeManagerAddress: convertToGenericAddress(
+      '0x2bddd0e17d806d6ec521addb3f921879d1f6c0e8' as EvmAddress,
+      ChainType.EVM
+    ),
+    priceFeedControllerAddress: convertToGenericAddress(
+      '0x428cfa65310c70bc9e65bddb26c65fe4ca490376' as EvmAddress,
+      ChainType.EVM
+    ),
+    spokeControllerAddress: convertToGenericAddress(
+      '0x8f8a0ed366439576b7db220678ed1259743239e3' as EvmAddress,
+      ChainType.EVM
+    ),
+    accountControllerAddress: convertToGenericAddress(
+      '0xc2df24203ab3a4f3857d649757a99e18de059a16' as EvmAddress,
+      ChainType.EVM
+    ),
+    loanControllerAddress: convertToGenericAddress(
+      '0xc4c20efbefa4bde14091a3040d112cf981d8b2db' as EvmAddress,
+      ChainType.EVM
+    ),
+    tokens: {
+      [MAINNET_TS_TOKEN_ID.USDC]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 6,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.USDC,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.USDC],
+        poolAddress: convertToGenericAddress(
+          '0xdb4e67f878289a820046f46f6304fd6ee1449281' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+          MAINNET_LOAN_TYPE_ID.STABLE_EFFICIENCY,
+        ]),
+      },
+      [MAINNET_TS_TOKEN_ID.MON]: {
+        token: {
+          type: TokenType.NATIVE,
+          decimals: 18,
+        },
+
+        TsTokenId: MAINNET_TS_TOKEN_ID.MON,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.MON],
+        poolAddress: convertToGenericAddress(
+          '0x106d0e2bff74b39d09636bdcd5d4189f24d91433' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+          MAINNET_LOAN_TYPE_ID.MON_EFFICIENCY,
+        ]),
+      },
+
+      [MAINNET_TS_TOKEN_ID.wMON]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 18,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.wMON,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.wMON],
+        poolAddress: convertToGenericAddress(
+          '0xf358f9e4ba7d210fde8c9a30522bb0063e15c4bb' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+          MAINNET_LOAN_TYPE_ID.MON_EFFICIENCY,
+        ]),
+      },
+
+      [MAINNET_TS_TOKEN_ID.AZND]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 18,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.AZND,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.AZND],
+        poolAddress: convertToGenericAddress(
+          '0xaa3f243731d724f2195271a9c3f5c744f0d0b948' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      [MAINNET_TS_TOKEN_ID.muBOND]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 18,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.muBOND,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.muBOND],
+        poolAddress: convertToGenericAddress(
+          '0x09cd0233ad57bac4f916ca7aa08321b96effbaf2' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      [MAINNET_TS_TOKEN_ID.AUSD]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 6,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.AUSD,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.AUSD],
+        poolAddress: convertToGenericAddress(
+          '0x7f5996865e952bd7892366712d319de59b9ecc6b' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      // [MAINNET_TS_TOKEN_ID.earnAUSD]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 6,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.earnAUSD,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.earnAUSD],
+      //   poolAddress: convertToGenericAddress(
+      //     '0x7d99267be583d46273803b2b1c5edb98bff6538d' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([
+      //     MAINNET_LOAN_TYPE_ID.GENERAL,
+      //     MAINNET_LOAN_TYPE_ID.DEPOSIT,
+      //   ]),
+      // },
+      // [MAINNET_TS_TOKEN_ID.IoAZND]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 18,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.IoAZND,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.IoAZND],
+      //   poolAddress: convertToGenericAddress(
+      //     '0x1122a5444ce12bba9f63f523e2f5155ebf046e92' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([
+      //     MAINNET_LOAN_TYPE_ID.GENERAL,
+      //     MAINNET_LOAN_TYPE_ID.DEPOSIT,
+      //   ]),
+      // },
+      [MAINNET_TS_TOKEN_ID.USD1]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 6,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.USD1,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.USD1],
+        poolAddress: convertToGenericAddress(
+          '0x3249df5ca0b825e7c3e7d84a4bb11c2eacd8c0f6' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      [MAINNET_TS_TOKEN_ID.WETH]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 18,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.WETH,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.WETH],
+        poolAddress: convertToGenericAddress(
+          '0x0394728ef18258ca21f782ce37ebf1a16799d7ef' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      [MAINNET_TS_TOKEN_ID.WBTC]: {
+        token: {
+          type: TokenType.ERC20,
+          decimals: 8,
+        },
+        TsTokenId: MAINNET_TS_TOKEN_ID.WBTC,
+        poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.WBTC],
+        poolAddress: convertToGenericAddress(
+          '0xd636d6ab7072483de6ddc067f9147f8c1e512f18' as EvmAddress,
+          ChainType.EVM
+        ),
+        supportedLoanTypes: new Set([
+          MAINNET_LOAN_TYPE_ID.GENERAL,
+          MAINNET_LOAN_TYPE_ID.DEPOSIT,
+        ]),
+      },
+      // [MAINNET_TS_TOKEN_ID.sMON]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 18,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.sMON,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.sMON],
+      //   poolAddress: convertToGenericAddress(
+      //     '0xc0fda7f80e772ac3f85735f66ecb1ac964a033f2' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([
+      //     MAINNET_LOAN_TYPE_ID.GENERAL,
+      //     MAINNET_LOAN_TYPE_ID.DEPOSIT,
+      //   ]),
+      // },
+      // [MAINNET_TS_TOKEN_ID.shMON]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 18,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.shMON,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.shMON],
+      //   poolAddress: convertToGenericAddress(
+      //     '0xd2108dec68089646c3d4d95f01ea42ee1142e7f4' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([
+      //     MAINNET_LOAN_TYPE_ID.GENERAL,
+      //     MAINNET_LOAN_TYPE_ID.DEPOSIT,
+      //   ]),
+      // },
+      // [MAINNET_TS_TOKEN_ID.gMON]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 18,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.gMON,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.gMON],
+      //   poolAddress: convertToGenericAddress(
+      //     '0x428bebf994c970656854eb66586583fe682cc1d3' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([MAINNET_LOAN_TYPE_ID.GENERAL]),
+      // },
+      // [MAINNET_TS_TOKEN_ID.aprMON]: {
+      //   token: {
+      //     type: TokenType.ERC20,
+      //     decimals: 18,
+      //   },
+      //   TsTokenId: MAINNET_TS_TOKEN_ID.aprMON,
+      //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.aprMON],
+      //   poolAddress: convertToGenericAddress(
+      //     '0xfdd72592a657775249da1b013ac1371ccd45d885' as EvmAddress,
+      //     ChainType.EVM
+      //   ),
+      //   supportedLoanTypes: new Set([
+      //     MAINNET_LOAN_TYPE_ID.GENERAL,
+      //     MAINNET_LOAN_TYPE_ID.DEPOSIT,
+      //   ]),
+      // },
+    } satisfies Record<MainnetTsTokenId, HubTokenData>,
+  },
+};

package/src/chains/evm/hub/modules/index.ts

@@ -0,0 +1,5 @@
+export * as TsHubLoan from './ts-hub-loan.js';
+export * as TSHubOracle from './ts-hub-oracle.js';
+export * as TSHubPool from './ts-hub-pool.js';
+export * as TSHubGmp from './ts-hub-gmp.js';
+export * as TSHubAccount from './ts-hub-account.js';

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

@@ -0,0 +1,117 @@
+import { Client } from 'viem';
+import { NetworkType, TSChainId } from '../../../../common/types/chain.js';
+import { GenericAddress } from '../../../../common/types/address.js';
+import type { AccountIdByAddress, AccountInfo } from '../types/account.js';
+import { getHubChain } from '../utils/chain.js';
+import { getAccountControllerContract } from '../utils/contract.js';
+import { getTsChainIdsByNetwork } from '../../../../common/utils/chain.js';
+import { multicall } from 'viem/actions';
+import { AccountId } from '../../../../common/types/lending.js';
+import { defaultEventParams } from '../../common/constant/contract.js';
+export async function getAccountIdByAddress(
+  provider: Client,
+  network: NetworkType,
+  address: GenericAddress,
+  tsChainIds?: Array<TSChainId>
+): Promise<AccountIdByAddress> {
+  const hubChain = getHubChain(network);
+  const accountController = getAccountControllerContract(
+    provider,
+    hubChain.accountControllerAddress
+  );
+  tsChainIds = tsChainIds ? tsChainIds : getTsChainIdsByNetwork(network);
+
+  const accountIds = await multicall(provider, {
+    contracts: tsChainIds.map((tsChainIds) => ({
+      address: accountController.address,
+      abi: accountController.abi,
+      functionName: 'getAccountIdOfAddressOnChain',
+      args: [address, tsChainIds],
+    })),
+    allowFailure: true,
+  });
+
+  const accountIdByAddress: AccountIdByAddress = [];
+
+  for (const [index, result] of accountIds.entries()) {
+    const tsChainId = tsChainIds[index];
+    if (result.status === 'success')
+      accountIdByAddress.push({
+        accountId: result.result as AccountId,
+        tsChainId,
+      });
+  }
+
+  return accountIdByAddress;
+}
+
+export async function isAccountCreated(
+  provider: Client,
+  network: NetworkType,
+  accountId: AccountId
+): Promise<boolean> {
+  const hubChain = getHubChain(network);
+  const accountController = getAccountControllerContract(
+    provider,
+    hubChain.accountControllerAddress
+  );
+
+  return await accountController.read.isAccountCreated([accountId]);
+}
+
+export async function getAccountInfo(
+  provider: Client,
+  network: NetworkType,
+  accountId: AccountId,
+  tsChainIds?: Array<TSChainId>
+): Promise<AccountInfo> {
+  const hubChain = getHubChain(network);
+
+  const accountController = getAccountControllerContract(
+    provider,
+    hubChain.accountControllerAddress
+  );
+
+  // get chain ids to check
+  tsChainIds = tsChainIds ? tsChainIds : getTsChainIdsByNetwork(network);
+
+  // define return variable
+  const accountInfo: AccountInfo = {
+    registered: new Map<TSChainId, GenericAddress>(),
+    invited: new Map<TSChainId, GenericAddress>(),
+  };
+
+  // query for registered and invited addresses on each respective chain
+  const registeredAddresses = await multicall(provider, {
+    contracts: tsChainIds.map((tsChainId) => ({
+      address: accountController.address,
+      abi: accountController.abi,
+      functionName: 'getAddressRegisteredToAccountOnChain',
+      args: [accountId, tsChainId],
+    })),
+    allowFailure: true,
+  });
+
+  const invitedAddresses = await multicall(provider, {
+    contracts: tsChainIds.map((tsChainId) => ({
+      address: accountController.address,
+      abi: accountController.abi,
+      functionName: 'getAddressInvitedToAccountOnChain',
+      args: [accountId, tsChainId],
+    })),
+    allowFailure: true,
+  });
+
+  for (const [index, result] of registeredAddresses.entries()) {
+    const chainId = tsChainIds[index];
+    if (result.status === 'success')
+      accountInfo.registered.set(chainId, result.result as GenericAddress);
+  }
+  for (const [index, result] of invitedAddresses.entries()) {
+    const chainId = tsChainIds[index];
+    if (result.status === 'success')
+      accountInfo.invited.set(chainId, result.result as GenericAddress);
+  }
+
+  return accountInfo;
+}

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

@@ -0,0 +1,231 @@
+import { FINALITY } from '../../../../common/constants/message.js';
+import { getRandomGenericAddress } from '../../../../common/utils/address.js';
+import { getRandomBytes } from '../../../../common/utils/bytes.js';
+import { increaseByPercent } from '../../../../common/utils/math-lib.js';
+import { RETRY_REVERSE_GAS_LIMIT_SLIPPAGE } from '../../common/constant/contract.js';
+import { getEvmSignerAccount } from '../../common/utils/chain.js';
+import {
+  buildMessageParams,
+  buildSendTokenExtraArgsWhenRemoving,
+} from '../../common/utils/message.js';
+import { getHubChainBridgeRouterAddress } from '../utils/chain.js';
+import { getBridgeRouterHubContract } from '../utils/contract.js';
+
+import type { EvmAddress } from '../../../../common/types/address.js';
+import type { TSChainId } from '../../../../common/types/chain.js';
+import type { MessageId } from '../../../../common/types/gmp.js';
+import type {
+  AdapterType,
+  MessageToSend,
+} from '../../../../common/types/message.js';
+import type { MessageReceived } from '../../common/types/gmp.js';
+import type {
+  PrepareRetryMessageCall,
+  PrepareReverseMessageCall,
+} from '../../common/types/module.js';
+import type { HubChain } from '../types/chain.js';
+import type { HubTokenData } from '../types/token.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,
+    hubChain: HubChain,
+    isRewards = false,
+    transactionOptions: EstimateGasParameters = {
+      account: sender,
+    }
+  ): Promise<PrepareRetryMessageCall> {
+    const bridgeRouterAddress = getHubChainBridgeRouterAddress(
+      hubChain,
+      isRewards
+    );
+    const bridgeRouter = getBridgeRouterHubContract(
+      provider,
+      bridgeRouterAddress
+    );
+
+    const gasLimit = await bridgeRouter.estimateGas.retryMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        ...transactionOptions,
+        value,
+      }
+    );
+
+    return {
+      gasLimit: increaseByPercent(gasLimit, RETRY_REVERSE_GAS_LIMIT_SLIPPAGE),
+      msgValue: value,
+      isHub: true,
+      message,
+      extraArgs,
+      bridgeRouterAddress: hubChain.hubMessageDispatcher,
+    };
+  },
+
+  async reverseMessage(
+    provider: Client,
+    sender: EvmAddress,
+    adapterId: AdapterType,
+    messageId: MessageId,
+    message: MessageReceived,
+    extraArgs: Hex,
+    value: bigint,
+    hubChain: HubChain,
+    isRewards = false,
+    transactionOptions: EstimateGasParameters = {
+      account: sender,
+    }
+  ): Promise<PrepareRetryMessageCall> {
+    const bridgeRouterAddress = getHubChainBridgeRouterAddress(
+      hubChain,
+      isRewards
+    );
+    const bridgeRouter = getBridgeRouterHubContract(
+      provider,
+      bridgeRouterAddress
+    );
+
+    const gasLimit = await bridgeRouter.estimateGas.reverseMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        ...transactionOptions,
+        value,
+      }
+    );
+
+    return {
+      gasLimit: increaseByPercent(gasLimit, RETRY_REVERSE_GAS_LIMIT_SLIPPAGE),
+      msgValue: value,
+      isHub: true,
+      message,
+      extraArgs,
+      bridgeRouterAddress: hubChain.hubMessageDispatcher,
+    };
+  },
+};
+
+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 = getBridgeRouterHubContract(
+      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 = getBridgeRouterHubContract(
+      provider,
+      bridgeRouterAddress,
+      signer
+    );
+
+    return await bridgeRouter.write.reverseMessage(
+      [adapterId, messageId, message, extraArgs],
+      {
+        account: getEvmSignerAccount(signer),
+        chain: signer.chain,
+        gas: gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        value: msgValue,
+      }
+    );
+  },
+};
+
+export async function getSendMessageFee(
+  provider: Client,
+  toTsChainId: TSChainId,
+  adapterId: AdapterType,
+  gasLimit: bigint,
+  hubChain: HubChain,
+  hubTokenData?: HubTokenData,
+  isRewards = false
+): Promise<bigint> {
+  const bridgeRouterAddress = getHubChainBridgeRouterAddress(
+    hubChain,
+    isRewards
+  );
+  const hubBridgeRouter = getBridgeRouterHubContract(
+    provider,
+    bridgeRouterAddress
+  );
+
+  // construct return message
+  const message: MessageToSend = {
+    params: buildMessageParams({
+      adapters: {
+        adapterId,
+        returnAdapterId: 0 as AdapterType,
+      },
+      gasLimit,
+    }),
+    sender: hubChain.hubAddress,
+    destinationChainId: toTsChainId,
+    handler: getRandomGenericAddress(),
+    payload: getRandomBytes(256),
+    finalityLevel: FINALITY.FINALISED,
+    extraArgs: hubTokenData
+      ? buildSendTokenExtraArgsWhenRemoving(
+          getRandomGenericAddress(),
+          hubTokenData.token,
+          1n
+        )
+      : '0x',
+  };
+
+  // get return adapter fee
+  return await hubBridgeRouter.read.getSendFee([message]);
+}