@townsq/mm-sdk 1.0.1

package/src/common/utils/gmp.ts

@@ -0,0 +1,8 @@
+import { WORMHOLE_DATA } from '../constants/gmp.js';
+
+import type { TSChainId } from '../types/chain.js';
+import type { CCIPData, WormholeData } from '../types/gmp.js';
+
+export function getWormholeData(tsChainId: TSChainId): WormholeData {
+  return WORMHOLE_DATA[tsChainId];
+}

package/src/common/utils/lending.ts

@@ -0,0 +1,31 @@
+import { concat, keccak256, pad, toHex } from 'viem';
+
+import { BYTES32_LENGTH, UINT16_LENGTH } from '../constants/byte.js';
+
+import { convertNumberToBytes } from './bytes.js';
+
+import type { GenericAddress } from '../types/address.js';
+import type { TSChainId } from '../types/chain.js';
+import type { AccountId, LoanId, LoanName, Nonce } from '../types/lending.js';
+
+export function isAccountId(accountId: AccountId): boolean {
+  return accountId.length === 64 + 2;
+}
+
+export function buildAccountId(
+  addr: GenericAddress,
+  chainId: TSChainId,
+  nonce: Nonce
+): AccountId {
+  return keccak256(
+    concat([addr, convertNumberToBytes(chainId, UINT16_LENGTH), nonce])
+  ) as AccountId;
+}
+
+export function buildLoanId(accountId: AccountId, nonce: Nonce): LoanId {
+  return keccak256(concat([accountId, nonce])) as LoanId;
+}
+
+export function convertStringToLoanName(name: string): LoanName {
+  return pad(toHex(name), { size: BYTES32_LENGTH }) as LoanName;
+}

package/src/common/utils/math-lib.ts

@@ -0,0 +1,50 @@
+import * as dn from "dnum";
+
+import type { Dnum } from "dnum";
+
+export const SECONDS_IN_YEAR = BigInt(365 * 24 * 60 * 60);
+export const HOURS_IN_YEAR = BigInt(365 * 24);
+
+export function unixTime(): number {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function expBySquaring(x: Dnum, n: bigint): Dnum {
+  const [, decimals] = x;
+  const one = dn.from(1, decimals);
+
+  if (n === BigInt(0)) return one;
+
+  let y = one;
+  while (n > BigInt(1)) {
+    if (n % BigInt(2)) {
+      y = dn.mul(x, y, { rounding: "ROUND_DOWN" });
+      n = (n - BigInt(1)) / BigInt(2);
+    } else {
+      n = n / BigInt(2);
+    }
+    x = dn.mul(x, x, { rounding: "ROUND_DOWN" });
+  }
+  return dn.mul(x, y, { rounding: "ROUND_DOWN" });
+}
+
+function compound(rate: Dnum, period: bigint): Dnum {
+  const [, decimals] = rate;
+  const one = dn.from(1, decimals);
+  return dn.sub(expBySquaring(dn.add(one, dn.div(rate, period)), period), one);
+}
+
+export function compoundEverySecond(rate: Dnum): Dnum {
+  return compound(rate, SECONDS_IN_YEAR);
+}
+
+export function compoundEveryHour(rate: Dnum): Dnum {
+  return compound(rate, HOURS_IN_YEAR);
+}
+
+export const bigIntMax = (...args: Array<bigint>) => args.reduce((m, e) => (e > m ? e : m));
+export const bigIntMin = (...args: Array<bigint>) => args.reduce((m, e) => (e < m ? e : m));
+
+export const increaseByPercent = (value: bigint, percent: number) => {
+  return value + (value * BigInt(10_000 * percent)) / BigInt(10_000);
+};

package/src/common/utils/messages.ts

@@ -0,0 +1,283 @@
+import {
+  bytesToBigInt,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  hexToBytes,
+  hexToNumber,
+  parseEventLogs,
+  sliceHex,
+} from 'viem';
+import { getTransactionReceipt } from 'viem/actions';
+
+import { WormholeDataAdapterAbi } from '../../chains/evm/common/constant/abi/wormhole-data-adapter-abi.js';
+import { GAS_LIMIT_ESTIMATE_INCREASE } from '../../chains/evm/common/constant/contract.js';
+import {
+  buildEvmMessageToSend,
+  estimateEvmWormholeDataGasLimit,
+  getSendTokenStateOverride,
+} from '../../chains/evm/common/utils/message.js';
+import { getHubChainAdapterAddress } from '../../chains/evm/hub/utils/chain.js';
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import {
+  BYTES32_LENGTH,
+  BYTES4_LENGTH,
+  UINT16_LENGTH,
+  UINT256_LENGTH,
+  UINT8_LENGTH,
+} from '../constants/byte.js';
+import {
+  REVERSIBLE_HUB_ACTIONS,
+  SEND_TOKEN_ACTIONS,
+} from '../constants/message.js';
+import { ChainType } from '../types/chain.js';
+import { MessageDirection } from '../types/gmp.js';
+import { Action, AdapterType } from '../types/message.js';
+
+import { convertFromGenericAddress } from './address.js';
+import { getTsChain, getSpokeChainAdapterAddress } from './chain.js';
+import { getWormholeData } from './gmp.js';
+import { waitTransaction } from './transaction.js';
+
+import type { GenericAddress } from '../types/address.js';
+import type { TSChainId, NetworkType } from '../types/chain.js';
+import type { TSProvider } from '../types/core.js';
+import type { AccountId, LoanId, LoanName, Nonce } from '../types/lending.js';
+import type {
+  MessageAdapters,
+  MessageBuilderParams,
+  MessageDataMap,
+  MessageToSend,
+  OptionalFeeParams,
+  Payload,
+} from '../types/message.js';
+
+import type { Client as EVMProvider, Hex, StateOverride } from 'viem';
+
+export function buildMessageToSend(
+  chainType: ChainType,
+  messageToSendBuilderParams: MessageBuilderParams,
+  feeParams: OptionalFeeParams = {}
+): MessageToSend {
+  switch (chainType) {
+    case ChainType.EVM: {
+      return buildEvmMessageToSend(messageToSendBuilderParams, feeParams);
+    }
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}
+
+function getAdapterId(
+  messageDirection: MessageDirection,
+  adapters: MessageAdapters
+): AdapterType {
+  if (messageDirection === MessageDirection.SpokeToHub)
+    return adapters.adapterId;
+  return adapters.returnAdapterId;
+}
+
+function getAdaptersAddresses(
+  messageDirection: MessageDirection,
+  sourceTSChainId: TSChainId,
+  destTSChainId: TSChainId,
+  network: NetworkType,
+  adapterId: AdapterType,
+  isRewards = false
+) {
+  if (messageDirection === MessageDirection.SpokeToHub)
+    return {
+      sourceAdapterAddress: getSpokeChainAdapterAddress(
+        sourceTSChainId,
+        network,
+        adapterId
+      ),
+      destAdapterAddress: getHubChainAdapterAddress(network, adapterId),
+    };
+  return {
+    sourceAdapterAddress: getHubChainAdapterAddress(network, adapterId),
+    destAdapterAddress: getSpokeChainAdapterAddress(
+      destTSChainId,
+      network,
+      adapterId
+    ),
+  };
+}
+
+export async function estimateAdapterReceiveGasLimit(
+  sourceTSChainId: TSChainId,
+  destTSChainId: TSChainId,
+  destTSChainProvider: TSProvider,
+  network: NetworkType,
+  messageDirection: MessageDirection,
+  messageBuilderParams: MessageBuilderParams,
+  receiverValue = BigInt(0),
+  returnGasLimit = BigInt(0),
+  isRewards = false
+) {
+  const destTsChain = getTsChain(destTSChainId, network);
+
+  const adapterId = getAdapterId(
+    messageDirection,
+    messageBuilderParams.adapters
+  );
+  const { sourceAdapterAddress, destAdapterAddress } = getAdaptersAddresses(
+    messageDirection,
+    sourceTSChainId,
+    destTSChainId,
+    network,
+    adapterId,
+    isRewards
+  );
+
+  switch (destTsChain.chainType) {
+    case ChainType.EVM: {
+      let stateOverride: StateOverride = [];
+      if (messageBuilderParams.action === Action.SendToken) {
+        stateOverride = stateOverride.concat(
+          getSendTokenStateOverride(
+            destTSChainId,
+            messageBuilderParams.overrideData
+          )
+        );
+      }
+      switch (adapterId) {
+        case AdapterType.HUB: {
+          return 500000n;
+        }
+        case AdapterType.WORMHOLE_DATA: {
+          const sourceWormholeChainId =
+            getWormholeData(sourceTSChainId).wormholeChainId;
+          const wormholeRelayer = convertFromGenericAddress(
+            getWormholeData(destTSChainId).wormholeRelayer,
+            ChainType.EVM
+          );
+
+          const gasLimitEstimation = await estimateEvmWormholeDataGasLimit(
+            // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+            destTSChainProvider as EVMProvider,
+            messageBuilderParams,
+            receiverValue,
+            returnGasLimit,
+            sourceWormholeChainId,
+            wormholeRelayer,
+            destAdapterAddress,
+            sourceAdapterAddress,
+            stateOverride
+          );
+          return gasLimitEstimation + GAS_LIMIT_ESTIMATE_INCREASE;
+        }
+
+        default:
+          return exhaustiveCheck(adapterId);
+      }
+    }
+    default:
+      return exhaustiveCheck(destTsChain.chainType);
+  }
+}
+
+export async function getOperationIdsByTransaction(
+  chainType: ChainType,
+  tsProvider: TSProvider,
+  txnHash: Hex
+) {
+  switch (chainType) {
+    case ChainType.EVM: {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const receipt = await getTransactionReceipt(tsProvider!, {
+        hash: txnHash,
+      });
+      const logs = parseEventLogs({
+        abi: WormholeDataAdapterAbi,
+        logs: receipt.logs,
+        eventName: 'SendMessage',
+      });
+      return logs.map((log) => log.args.operationId);
+    }
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}
+
+export async function waitOperationIds(
+  chainType: ChainType,
+  tsProvider: TSProvider,
+  txnHash: Hex,
+  confirmations = 1
+) {
+  switch (chainType) {
+    case ChainType.EVM: {
+      const receipt = await waitTransaction(
+        chainType,
+        tsProvider,
+        txnHash,
+        confirmations
+      );
+      return await getOperationIdsByTransaction(
+        chainType,
+        tsProvider,
+        receipt.transactionHash
+      );
+    }
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}
+
+export function isReversibleAction(
+  action: Action,
+  messageDirection: MessageDirection
+) {
+  return (
+    messageDirection === MessageDirection.HubToSpoke &&
+    REVERSIBLE_HUB_ACTIONS.includes(action as any)
+  );
+}
+
+export function assertReversibleAction(
+  action: Action,
+  messageDirection: MessageDirection
+) {
+  if (!isReversibleAction(action, messageDirection))
+    throw new Error(
+      `Action ${action} is not reversible for message direction ${messageDirection}`
+    );
+}
+
+export function isRetryableAction(
+  action: Action,
+  messageDirection: MessageDirection
+) {
+  return (
+    messageDirection === MessageDirection.HubToSpoke ||
+    SEND_TOKEN_ACTIONS.includes(action as any)
+  );
+}
+
+export function assertRetryableAction(
+  action: Action,
+  messageDirection: MessageDirection
+) {
+  if (!isRetryableAction(action, messageDirection))
+    throw new Error(
+      `Action ${action} is not retryable for message direction ${messageDirection}`
+    );
+}
+
+export function decodeMessagePayload(payload: Hex): Payload {
+  return {
+    action: hexToNumber(sliceHex(payload, 0, UINT16_LENGTH)) as Action,
+    accountId: sliceHex(
+      payload,
+      UINT16_LENGTH,
+      UINT16_LENGTH + BYTES32_LENGTH
+    ) as AccountId,
+    userAddr: sliceHex(
+      payload,
+      UINT16_LENGTH + BYTES32_LENGTH,
+      UINT16_LENGTH + BYTES32_LENGTH + BYTES32_LENGTH
+    ) as GenericAddress,
+    data: sliceHex(payload, UINT16_LENGTH + BYTES32_LENGTH + BYTES32_LENGTH),
+  };
+}

package/src/common/utils/token.ts

@@ -0,0 +1,13 @@
+import { TS_TOKEN_IDS_FROM_POOL_BY_NETWORK } from '../constants/pool.js';
+
+import type { NetworkType } from '../types/chain.js';
+import type { TSTokenId } from '../types/token.js';
+
+export function getTSTokenIdFromPool(
+  poolId: number,
+  network: NetworkType
+): TSTokenId {
+  const tsTokenId = TS_TOKEN_IDS_FROM_POOL_BY_NETWORK[network][poolId];
+  if (!tsTokenId) throw new Error(`Unknown poolId: ${poolId}`);
+  return tsTokenId;
+}

package/src/common/utils/transaction.ts

@@ -0,0 +1,27 @@
+import { waitForTransactionReceipt } from 'viem/actions';
+
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import { ChainType } from '../types/chain.js';
+
+import type { TSProvider } from '../types/core.js';
+import type { Hex, TransactionReceipt } from 'viem';
+
+export async function waitTransaction(
+  chainType: ChainType,
+  tsProvider: TSProvider,
+  txnHash: Hex,
+  confirmations = 1
+): Promise<TransactionReceipt> {
+  switch (chainType) {
+    case ChainType.EVM: {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const receipt = await waitForTransactionReceipt(tsProvider!, {
+        hash: txnHash,
+        confirmations,
+      });
+      return receipt;
+    }
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+export { TSCore } from './lifeline/core/ts-core.js';
+
+// === CORE ===
+
+// === MODULES ===
+export {
+  TSAccount,
+  TSLoan, //
+  TSOracle, //
+  TSPool, //
+  TSGmp,
+} from './lifeline/modules/index.js';
+
+// === COMMON ===
+export * from './common/types/adapter.js';
+export * from './common/types/address.js';
+export * from './common/types/chain.js';
+export * from './common/types/core.js';
+
+export * from './common/types/lending.js';
+export * from './common/types/message.js';
+export * from './common/types/module.js';
+export * from './common/types/token.js';
+// ./common/constants/bytes.js
+export * from './common/constants/byte.js';
+export * from './common/constants/chain.js';
+export * from './common/constants/gmp.js';
+export * from './common/constants/message.js';
+export * from './common/constants/pool.js';
+
+// ./common/utils/adapter.js
+export { getSupportedMessageAdapters } from './common/utils/adapter.js';
+export {
+  convertFromGenericAddress,
+  convertToGenericAddress,
+} from './common/utils/address.js';
+export { getRandomBytes } from './common/utils/bytes.js';
+export { getAdapterAddress } from './common/utils/chain.js';
+export {
+  toFAmount,
+  toUnderlyingAmount,
+  calcAssetDollarValue,
+} from './common/utils/formulae.js';
+// ./common/utils/gmp.js
+export { getWormholeData } from './common/utils/gmp.js';
+export { buildAccountId, buildLoanId } from './common/utils/lending.js';
+
+export { waitTransaction } from './common/utils/transaction.js';
+
+// === HUB ===
+export { isHubChain } from './chains/evm/hub/utils/chain.js';
+export { HUB_CHAIN } from './chains/evm/hub/constants/chain.js';
+
+// === CHAINS ===
+
+// - EVM
+export * from './chains/evm/common/constant/chain.js';
+
+export * from './chains/evm/common/types/chain.js';
+
+export { isEvmChainId } from './chains/evm/common/utils/chain.js';
+
+// - EVM: HUB
+export * from './chains/evm/hub/types/account.js';
+export * from './chains/evm/hub/types/chain.js';
+export * from './chains/evm/hub/types/loan.js';
+export * from './chains/evm/hub/types/oracle.js';
+export * from './chains/evm/hub/types/pool.js';
+
+export * from './chains/evm/hub/types/token.js';
+
+// - EVM: SPOKE
+export * from './chains/evm/spoke/types/pool.js';

package/src/lifeline/core/ts-core.ts

@@ -0,0 +1,136 @@
+import { initProviders } from '../../chains/evm/common/utils/provider.js';
+import { getHubChain } from '../../chains/evm/hub/utils/chain.js';
+import { ChainType } from '../../common/types/chain.js';
+import { getTsChain } from '../../common/utils/chain.js';
+// ../../chains/evm/hub/utils/chain.js
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+
+import type {
+  TSChainId,
+  TSChain,
+  NetworkType,
+} from '../../common/types/chain.js';
+import type {
+  TSCoreProvider,
+  TSSigner,
+  TSCoreConfig,
+  TSProviderType,
+  TSSignerType,
+  TSProvider,
+} from '../../common/types/core.js';
+import type { Client as EVMProvider } from 'viem';
+
+export class TSCore {
+  private static instance: TSCore | undefined;
+  private tsCoreProvider: TSCoreProvider;
+
+  private selectedNetwork: NetworkType;
+  private tsSigner?: TSSigner;
+
+  private constructor(tsCoreConfig: TSCoreConfig) {
+    this.selectedNetwork = tsCoreConfig.network;
+    this.tsCoreProvider = { evm: {} as Record<TSChainId, EVMProvider> };
+    this.tsCoreProvider.evm = initProviders(tsCoreConfig.provider.evm);
+  }
+
+  static init(tsCoreConfig: TSCoreConfig): TSCore {
+    if (TSCore.instance) throw new Error('TownsqCore is already initialized');
+    TSCore.instance = new TSCore(tsCoreConfig);
+    return TSCore.instance;
+  }
+
+  static isInitialized(): boolean {
+    return !!TSCore.instance;
+  }
+
+  static getInstance(): TSCore {
+    if (TSCore.instance) return TSCore.instance;
+    throw new Error('TSCore is not initialized');
+  }
+
+  static getProvider<T extends ChainType>(
+    tsChainId: TSChainId
+  ): TSProviderType<T> {
+    const tsChain = getTsChain(tsChainId, this.getSelectedNetwork());
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        return TSCore.getEVMProvider(tsChainId) as TSProviderType<T>;
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  }
+
+  static getTSSigner() {
+    const instance = this.getInstance();
+    if (!instance.tsSigner) throw new Error('TSSigner is not initialized');
+
+    return instance.tsSigner;
+  }
+
+  static getSigner<T extends ChainType>(): TSSignerType<T> {
+    const { signer } = this.getTSSigner();
+
+    return signer as TSSignerType<T>;
+  }
+
+  static getSelectedTsChain(): TSChain {
+    const { tsChainId } = this.getTSSigner();
+
+    return getTsChain(tsChainId, this.getSelectedNetwork());
+  }
+
+  static getSelectedNetwork() {
+    const instance = this.getInstance();
+    return instance.selectedNetwork;
+  }
+
+  static getHubProvider(): EVMProvider {
+    const instance = this.getInstance();
+    const hubTsChainId = getHubChain(instance.selectedNetwork).tsChainId;
+
+    const hubProvider = instance.tsCoreProvider.evm[hubTsChainId];
+    if (!hubProvider) throw new Error(`Hub Provider has not been initialized`);
+
+    return hubProvider;
+  }
+
+  static setProvider(tsChainId: TSChainId, provider: TSProvider) {
+    const instance = this.getInstance();
+    const tsChain = getTsChain(tsChainId, this.getSelectedNetwork());
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style -- in the future TSProvider will contain more than just EVMProvider
+        instance.tsCoreProvider.evm[tsChainId] = provider as EVMProvider;
+        break;
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  }
+
+  static setNetwork(network: NetworkType) {
+    const instance = this.getInstance();
+    instance.selectedNetwork = network;
+  }
+
+  static setTSsSigner(tsSigner: TSSigner) {
+    const instance = this.getInstance();
+    const tsChain = getTsChain(tsSigner.tsChainId, this.getSelectedNetwork());
+
+    switch (tsChain.chainType) {
+      case ChainType.EVM:
+        instance.tsSigner = tsSigner;
+        break;
+      default:
+        return exhaustiveCheck(tsChain.chainType);
+    }
+  }
+
+  static getEVMProvider(tsChainId: TSChainId): EVMProvider {
+    const instance = this.getInstance();
+    const evmProvider = instance.tsCoreProvider.evm[tsChainId];
+    if (!evmProvider)
+      throw new Error(`EVM Provider not found for tsChainId: ${tsChainId}`);
+
+    return evmProvider;
+  }
+}

package/src/lifeline/modules/index.ts

@@ -0,0 +1,5 @@
+export * as TSAccount from './ts-account.js';
+export * as TSLoan from './ts-loan.js';
+export * as TSOracle from './ts-oracle.js';
+export * as TSPool from './ts-pool.js';
+export * as TSGmp from './ts-gmp.js';