@townsq/mm-sdk 1.0.1

package/src/chains/evm/spoke/types/pool.ts

@@ -0,0 +1,7 @@
+export type TokenRateLimit = {
+  periodLength: bigint;
+  periodOffset: bigint;
+  periodLimit: bigint;
+  currentCapacity: bigint;
+  nextPeriodReset: bigint;
+};

package/src/chains/evm/spoke/utils/contract.ts

@@ -0,0 +1,123 @@
+import { getContract } from 'viem';
+
+import { SPOKE_CHAIN } from '../../../../common/constants/chain.js';
+import { ChainType } from '../../../../common/types/chain.js';
+import { TokenType } from '../../../../common/types/token.js';
+import { convertFromGenericAddress } from '../../../../common/utils/address.js';
+import { SpokeMessageDispatcherAbi } from '../constants/abi/bridge-router-spoke-abi.js';
+import { SpokeOperationAbi } from '../constants/abi/spoke-common-abi.js';
+import { SpokeRewardsV2CommonAbi } from '../constants/abi/spoke-rewards-v2-common-abi.js';
+import { SpokeTokenAbi } from '../constants/abi/spoke-token-abi.js';
+
+import type { GenericAddress } from '../../../../common/types/address.js';
+import type { TSChainId, NetworkType } from '../../../../common/types/chain.js';
+import type { TSTokenId } from '../../../../common/types/token.js';
+import type { GetReadContractReturnType } from '../../common/types/contract.js';
+import type { Client, GetContractReturnType, WalletClient } from 'viem';
+
+export function getSpokeOperationContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof SpokeOperationAbi>;
+export function getSpokeOperationContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof SpokeOperationAbi, Client>;
+export function getSpokeOperationContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof SpokeOperationAbi>
+  | GetContractReturnType<typeof SpokeOperationAbi, Client> {
+  return getContract({
+    abi: SpokeOperationAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getSpokeMessageDispatcherContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof SpokeMessageDispatcherAbi>;
+export function getSpokeMessageDispatcherContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof SpokeMessageDispatcherAbi, Client>;
+export function getSpokeMessageDispatcherContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+): GetReadContractReturnType<typeof SpokeMessageDispatcherAbi> {
+  return getContract({
+    abi: SpokeMessageDispatcherAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getSpokeTokenContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof SpokeTokenAbi>;
+export function getSpokeTokenContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof SpokeTokenAbi, Client>;
+export function getSpokeTokenContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof SpokeTokenAbi>
+  | GetContractReturnType<typeof SpokeTokenAbi, Client> {
+  return getContract({
+    abi: SpokeTokenAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getSpokeRewardsV2CommonContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof SpokeRewardsV2CommonAbi>;
+export function getSpokeRewardsV2CommonContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof SpokeRewardsV2CommonAbi, Client>;
+export function getSpokeRewardsV2CommonContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof SpokeRewardsV2CommonAbi>
+  | GetContractReturnType<typeof SpokeRewardsV2CommonAbi, Client> {
+  return getContract({
+    abi: SpokeRewardsV2CommonAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getSpokeEvmTokenAddress(
+  network: NetworkType,
+  tsChainId: TSChainId,
+  tsTokenId: TSTokenId
+) {
+  const spokeToken = SPOKE_CHAIN[network][tsChainId]?.tokens[tsTokenId]?.token;
+  if (!spokeToken)
+    throw new Error(
+      `Spoke token not found for network: ${network}, tsChainId: ${tsChainId}, tsTokenId: ${tsTokenId}`
+    );
+  if (spokeToken.type === TokenType.NATIVE)
+    throw new Error(
+      `Spoke token is native for network: ${network}, tsChainId: ${tsChainId}, tsTokenId: ${tsTokenId}`
+    );
+  return convertFromGenericAddress(spokeToken.address, ChainType.EVM);
+}

package/src/common/constants/adapter.ts

@@ -0,0 +1,6 @@
+import { AdapterType } from '../types/message.js';
+
+export const DATA_ADAPTERS = [
+  AdapterType.HUB,
+  // AdapterType.WORMHOLE_DATA,
+] as const;

package/src/common/constants/byte.ts

@@ -0,0 +1,7 @@
+export const UINT8_LENGTH = 1;
+export const UINT16_LENGTH = 2;
+export const UINT256_LENGTH = 32;
+export const BYTES4_LENGTH = 4;
+export const BYTES32_LENGTH = 32;
+
+export const EVM_ADDRESS_BYTES_LENGTH = 20;

package/src/common/constants/chain.ts

@@ -0,0 +1,319 @@
+import {
+  arbitrum,
+  arbitrumSepolia,
+  avalanche,
+  avalancheFuji,
+  base,
+  baseSepolia,
+  bsc,
+  bscTestnet,
+  mainnet,
+  polygon,
+  sepolia,
+} from 'viem/chains';
+import { monadMainnet } from '../../chains/evm/common/constant/chain.js';
+import {
+  MAINNET_EVM_TS_CHAIN_ID,
+  TESTNET_EVM_TS_CHAIN_ID,
+} from '../../chains/evm/common/constant/chain.js';
+import { NetworkType, ChainType } from '../types/chain.js';
+import { AdapterType } from '../types/message.js';
+import { MAINNET_TS_TOKEN_ID, TokenType } from '../types/token.js';
+import { convertToGenericAddress } from '../utils/address.js';
+
+import { MAINNET_POOLS } from './pool.js';
+
+import type { EvmAddress } from '../types/address.js';
+import type {
+  TSChainId,
+  TSChain,
+  SpokeChain,
+  TSChainName,
+  MainnetTsChainId,
+} from '../types/chain.js';
+
+export const MAINNET_TS_CHAIN_ID = {
+  ...MAINNET_EVM_TS_CHAIN_ID,
+} as const;
+
+export const TS_CHAIN_ID = {
+  ...MAINNET_TS_CHAIN_ID,
+};
+
+export const TS_CHAIN: Record<
+  NetworkType,
+  Partial<Record<TSChainId, TSChain>>
+> = {
+  [NetworkType.MAINNET]: {
+    [TS_CHAIN_ID.MONAD]: {
+      chainType: ChainType.EVM,
+      tsChainId: TS_CHAIN_ID.MONAD,
+      chainName: monadMainnet.name,
+      chainId: monadMainnet.id,
+      network: NetworkType.MAINNET,
+    },
+  } satisfies Record<MainnetTsChainId, TSChain>,
+} as const;
+
+export const SPOKE_CHAIN: Record<
+  NetworkType,
+  Partial<Record<TSChainId, SpokeChain>>
+> = {
+  [NetworkType.MAINNET]: {
+    [TS_CHAIN_ID.MONAD]: {
+      tsChainId: TS_CHAIN_ID.MONAD,
+      spokeOperationAddress: convertToGenericAddress(
+        '0x63cb1cf5accbcc57e0cca047be9673ea5022b8db' as EvmAddress,
+        ChainType.EVM
+      ),
+      messageDispatcherAddress: convertToGenericAddress(
+        '0xb4a545a183bd072548ddfe9ddadc2c6f962ac14f' as EvmAddress,
+        ChainType.EVM
+      ),
+      adapters: {
+        [AdapterType.HUB]: convertToGenericAddress(
+          '0x2970fde6064178d51d961689cb5b64226ab11fc2' as EvmAddress,
+          ChainType.EVM
+        ),
+      },
+      tokens: {
+        [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],
+          spokeAddress: convertToGenericAddress(
+            '0x0392354326960f891926835eedab127766b21668' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.wMON]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 18,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.wMON,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.wMON],
+          spokeAddress: convertToGenericAddress(
+            '0xa2B1AC2Bb0a6Ad5E74D74F8809A2F935813d273a' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.USDC]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x754704Bc059F8C67012fEd69BC8A327a5aafb603' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 6,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.USDC,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.USDC],
+          spokeAddress: convertToGenericAddress(
+            '0xa457235b68606a7921b7c525d92e9592e793b4c0' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.AZND]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x4917a5ec9fCb5e10f47CBB197aBe6aB63be81fE8' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 18,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.AZND,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.AZND],
+          spokeAddress: convertToGenericAddress(
+            '0x21883c045311fc211dcb102280857cacd6cd11a0' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.muBOND]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x336D414754967C6682B5A665C7DAF6F1409E63e8' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 18,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.muBOND,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.muBOND],
+          spokeAddress: convertToGenericAddress(
+            '0x65602dbA7c8C8bC9c64a0Dea9aC80d173998fEaa' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.AUSD]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 6,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.AUSD,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.AUSD],
+          spokeAddress: convertToGenericAddress(
+            '0xbf97097a38af76416c1e67fa072bdfde080241cd' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        // [MAINNET_TS_TOKEN_ID.earnAUSD]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0x103222f020e98Bba0AD9809A011FDF8e6F067496' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 6,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.earnAUSD,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.earnAUSD],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0x184da9d07f5301eeb62b87b5f4f4e65f8114f0fd' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+        // [MAINNET_TS_TOKEN_ID.IoAZND]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0x9c82eB49B51F7Dc61e22Ff347931CA32aDc6cd90' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 18,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.IoAZND,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.IoAZND],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0x1defe62f5455538ec89b80ccd9c55f9e5df29d31' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+        [MAINNET_TS_TOKEN_ID.USD1]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x111111d2bf19e43C34263401e0CAd979eD1cdb61' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 6,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.USD1,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.USD1],
+          spokeAddress: convertToGenericAddress(
+            '0x2d8bbbd148fb36ec7802fb5b3aa5e12c1611026a' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.WETH]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0xEE8c0E9f1BFFb4Eb878d8f15f368A02a35481242' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 18,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.WETH,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.WETH],
+          spokeAddress: convertToGenericAddress(
+            '0xd75c4342d1f5bfd3eaaf4c7b39cda9aa8f64ab9c' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        [MAINNET_TS_TOKEN_ID.WBTC]: {
+          token: {
+            type: TokenType.ERC20,
+            address: convertToGenericAddress(
+              '0x0555E30da8f98308EdB960aa94C0Db47230d2B9c' as EvmAddress,
+              ChainType.EVM
+            ),
+            decimals: 8,
+          },
+          TsTokenId: MAINNET_TS_TOKEN_ID.WBTC,
+          poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.WBTC],
+          spokeAddress: convertToGenericAddress(
+            '0x9f9524c49330d23e088953842c34759f795fd4e9' as EvmAddress,
+            ChainType.EVM
+          ),
+        },
+        // [MAINNET_TS_TOKEN_ID.sMON]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0xA3227C5969757783154C60bF0bC1944180ed81B9' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 18,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.sMON,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.sMON],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0x4461d789d599fe1f89936ecbcb9ae11bf1ee6440' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+        // [MAINNET_TS_TOKEN_ID.shMON]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0x1B68626dCa36c7fE922fD2d55E4f631d962dE19c' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 18,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.shMON,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.shMON],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0x359c20164d7b64310e376de609ee511ab49185cf' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+        // [MAINNET_TS_TOKEN_ID.gMON]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0x8498312A6B3CbD158bf0c93AbdCF29E6e4F55081' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 18,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.gMON,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.gMON],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0xc4bcdf95ad95ed26258e167c95c87c73efdfb2aa' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+        // [MAINNET_TS_TOKEN_ID.aprMON]: {
+        //   token: {
+        //     type: TokenType.ERC20,
+        //     address: convertToGenericAddress(
+        //       '0x0c65A0BC65a5D819235B71F554D210D3F80E0852' as EvmAddress,
+        //       ChainType.EVM
+        //     ),
+        //     decimals: 18,
+        //   },
+        //   TsTokenId: MAINNET_TS_TOKEN_ID.aprMON,
+        //   poolId: MAINNET_POOLS[MAINNET_TS_TOKEN_ID.aprMON],
+        //   spokeAddress: convertToGenericAddress(
+        //     '0xb1a54ea5f0c700454bce454144fb8e6e6254a3c7' as EvmAddress,
+        //     ChainType.EVM
+        //   ),
+        // },
+      },
+    },
+  } satisfies Record<MainnetTsChainId, SpokeChain>,
+};

package/src/common/constants/gmp.ts

@@ -0,0 +1,19 @@
+import { ChainType } from '../types/chain.js';
+import { convertToGenericAddress } from '../utils/address.js';
+
+import { TS_CHAIN_ID } from './chain.js';
+
+import type { EvmAddress } from '../types/address.js';
+import type { TSChainId } from '../types/chain.js';
+import type { CCIPData, WormholeData } from '../types/gmp.js';
+
+export const WORMHOLE_DATA: Record<TSChainId, WormholeData> = {
+  [TS_CHAIN_ID.MONAD]: {
+    wormholeChainId: 48,
+    wormholeRelayer: convertToGenericAddress(
+      '0x362fca37E45fe1096b42021b543f462D49a5C8df' as EvmAddress,
+      ChainType.EVM
+    ),
+  },
+};
+ 

package/src/common/constants/lending.ts

@@ -0,0 +1,9 @@
+import { getEmptyBytes } from '../utils/bytes.js';
+
+import { BYTES32_LENGTH } from './byte.js';
+
+import type { AccountId } from '../types/lending.js';
+
+export const NULL_ACCOUNT_ID: AccountId = getEmptyBytes(
+  BYTES32_LENGTH
+) as AccountId;

package/src/common/constants/message.ts

@@ -0,0 +1,25 @@
+import { Action } from '../types/message.js';
+
+export const FINALITY = {
+  IMMEDIATE: BigInt(0),
+  FINALISED: BigInt(1),
+} as const;
+
+export const REVERSIBLE_HUB_ACTIONS = [
+  Action.InitiateLoanAccountWithDeposit,
+  Action.Deposit,
+  Action.Repay,
+] as const;
+
+export const SEND_TOKEN_ACTIONS = [
+  Action.InitiateLoanAccountWithDeposit,
+  Action.Deposit,
+  Action.Repay,
+] as const;
+export const RECEIVE_TOKEN_ACTIONS = [Action.Withdraw, Action.Borrow] as const;
+export const HUB_ACTIONS = [
+  Action.DepositTsToken,
+  Action.WithdrawTsToken,
+  Action.Liquidate,
+  Action.SendToken,
+] as const;

package/src/common/constants/pool.ts

@@ -0,0 +1,30 @@
+import { NetworkType } from '../types/chain.js';
+import { MAINNET_TS_TOKEN_ID } from '../types/token.js';
+
+import type { MainnetTsTokenId, TSTokenId } from '../types/token.js';
+
+export const MAINNET_POOLS = {
+  [MAINNET_TS_TOKEN_ID.MON]: 2,
+  [MAINNET_TS_TOKEN_ID.wMON]: 4,
+  [MAINNET_TS_TOKEN_ID.USDC]: 10,
+  [MAINNET_TS_TOKEN_ID.AZND]: 5,
+  [MAINNET_TS_TOKEN_ID.muBOND]: 6,
+  [MAINNET_TS_TOKEN_ID.AUSD]: 7,
+  // [MAINNET_TS_TOKEN_ID.earnAUSD]: 11,
+  // [MAINNET_TS_TOKEN_ID.IoAZND]: 17,
+  [MAINNET_TS_TOKEN_ID.USD1]: 18,
+  [MAINNET_TS_TOKEN_ID.WETH]: 15,
+  [MAINNET_TS_TOKEN_ID.WBTC]: 16,
+  // [MAINNET_TS_TOKEN_ID.shMON]: 14,
+  // [MAINNET_TS_TOKEN_ID.aprMON]: 13,
+  // [MAINNET_TS_TOKEN_ID.gMON]: 12,
+  // [MAINNET_TS_TOKEN_ID.sMON]: 8,
+} as const satisfies Record<MainnetTsTokenId, number>;
+
+const MAINNET_TS_TOKEN_IDS_FROM_POOL = Object.fromEntries(
+  Object.entries(MAINNET_POOLS).map(([token, poolId]) => [poolId, token])
+) as Partial<Record<number, TSTokenId>>;
+
+export const TS_TOKEN_IDS_FROM_POOL_BY_NETWORK = {
+  [NetworkType.MAINNET]: MAINNET_TS_TOKEN_IDS_FROM_POOL,
+} as Record<NetworkType, Partial<Record<number, TSTokenId>>>;

package/src/common/types/adapter.ts

@@ -0,0 +1,44 @@
+import type { TSChainId, NetworkType } from './chain.js';
+import type {
+  ClaimRewardAction,
+  DataAction,
+  ReceiveTokenAction,
+  SendTokenAction,
+} from './message.js';
+
+import type { TSTokenId } from './token.js';
+
+export enum MessageAdapterParamsType {
+  SendToken,
+  ReceiveToken,
+  Data,
+}
+
+export type SendTokenMessageAdapterParams = {
+  messageAdapterParamType: MessageAdapterParamsType.SendToken;
+  action: SendTokenAction;
+  network: NetworkType;
+  sourceTsChainId: TSChainId;
+  tsTokenId: TSTokenId;
+};
+
+export type ReceiveTokenMessageAdapterParams = {
+  messageAdapterParamType: MessageAdapterParamsType.ReceiveToken;
+  action: ReceiveTokenAction;
+  network: NetworkType;
+  sourceTsChainId: TSChainId;
+  destTsChainId: TSChainId;
+  tsTokenId: TSTokenId;
+};
+
+export type DataMessageAdapterParams = {
+  messageAdapterParamType: MessageAdapterParamsType.Data;
+  action: DataAction;
+  network: NetworkType;
+  sourceTsChainId: TSChainId;
+};
+
+export type MessageAdapterParams =
+  | SendTokenMessageAdapterParams
+  | ReceiveTokenMessageAdapterParams
+  | DataMessageAdapterParams;

package/src/common/types/address.ts

@@ -0,0 +1,11 @@
+import type { Branded } from './brand.js';
+import { ChainType } from './chain.js';
+
+export type GenericAddress = Branded<`0x${string}`, 'GenericAddress'>;
+export type EvmAddress = Branded<`0x${string}`, 'EvmAddress'>;
+
+type AddressTypeMap = {
+  [ChainType.EVM]: EvmAddress;
+};
+
+export type AddressType<T extends ChainType> = AddressTypeMap[T];

package/src/common/types/brand.ts

@@ -0,0 +1,3 @@
+declare const __brand: unique symbol;
+type Brand<B> = { [__brand]: B };
+export type Branded<T, B> = T & Brand<B>;

package/src/common/types/chain.ts

@@ -0,0 +1,42 @@
+import type { GenericAddress } from './address.js';
+import type { AdapterType } from './message.js';
+
+import type { TSTokenId, SpokeTokenData } from './token.js';
+import type { EvmChainName } from '../../chains/evm/common/types/chain.js';
+import type {
+  TS_CHAIN_ID,
+  MAINNET_TS_CHAIN_ID,
+
+} from '../constants/chain.js';
+
+export enum ChainType {
+  EVM = 'EVM',
+}
+
+export enum NetworkType {
+  MAINNET = 'MAINNET',
+}
+
+export type TSChainName = EvmChainName;
+export type MainnetTsChainId =
+  (typeof MAINNET_TS_CHAIN_ID)[keyof typeof MAINNET_TS_CHAIN_ID];
+
+export type TSChainId = (typeof TS_CHAIN_ID)[keyof typeof TS_CHAIN_ID];
+
+export type ITSChain = {
+  tsChainId: TSChainId;
+};
+
+export type TSChain = {
+  chainName: string;
+  chainType: ChainType;
+  chainId: number | string | undefined;
+  network: NetworkType;
+} & ITSChain;
+
+export type SpokeChain = {
+  spokeOperationAddress: GenericAddress;
+  messageDispatcherAddress: GenericAddress;
+  adapters: Partial<Record<AdapterType, GenericAddress>>;
+  tokens: Partial<Record<TSTokenId, SpokeTokenData>>;
+} & ITSChain;

package/src/common/types/core.ts

@@ -0,0 +1,31 @@
+import type { ChainType, NetworkType, TSChainId } from './chain.js';
+import type { Client as EVMProvider, WalletClient as EVMSigner } from 'viem';
+
+type TSProviderTypeMap = {
+  [ChainType.EVM]: EVMProvider;
+};
+
+type TSSignerTypeMap = {
+  [ChainType.EVM]: EVMSigner;
+};
+
+export type TSProviderType<T extends ChainType> = TSProviderTypeMap[T];
+export type TSSignerType<T extends ChainType> = TSSignerTypeMap[T];
+
+export type TSProvider = EVMProvider | null;
+export type TSSigner = { signer: EVMSigner; tsChainId: TSChainId };
+
+export type TSCoreProvider = {
+  evm: Partial<Record<TSChainId, EVMProvider>>;
+};
+export type TSCoreConfig = {
+  network: NetworkType;
+  provider: TSCoreProvider;
+};
+
+export type TSEvmSigner = {
+  signer: EVMSigner;
+  chainType: ChainType.EVM;
+};
+
+export type TSChainSigner = TSEvmSigner;