@townsq/mm-sdk 1.0.1

package/src/common/utils/adapter.ts

@@ -0,0 +1,197 @@
+import {
+  getHubTokenData,
+  isHubChain,
+} from '../../chains/evm/hub/utils/chain.js';
+import { ensureNonEmpty, intersect } from '../../utils/array.js';
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import { TSCore } from '../../lifeline/core/ts-core.js';
+import { DATA_ADAPTERS } from '../constants/adapter.js';
+import { MessageAdapterParamsType } from '../types/adapter.js';
+import { AdapterType } from '../types/message.js';
+import { TokenType } from '../types/token.js';
+
+import { getSpokeChain } from './chain.js';
+
+import type { NonEmptyArray } from '../../types/generics.js';
+import type {
+  MessageAdapterParams,
+  ReceiveTokenMessageAdapterParams,
+} from '../types/adapter.js';
+import type { TSChainId, NetworkType } from '../types/chain.js';
+import type { SupportedMessageAdaptersMap } from '../types/message.js';
+import type { CrossChainTokenType, TSTokenId } from '../types/token.js';
+
+export function getSpokeAdapterIds(
+  tsChainId: TSChainId,
+  network: NetworkType
+): NonEmptyArray<AdapterType> {
+  const spokeChain = getSpokeChain(tsChainId, network);
+  const { adapters } = spokeChain;
+  const adapterIds = Object.keys(adapters).map<AdapterType>(Number);
+  return ensureNonEmpty(adapterIds, `No adapters found for chain ${tsChainId}`);
+}
+
+export function doesAdapterSupportDataMessage(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): boolean {
+  const isHub = isHubChain(tsChainId, TSCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && adapterId === AdapterType.WORMHOLE_DATA)
+  );
+}
+
+export function assertAdapterSupportsDataMessage(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): void {
+  if (!doesAdapterSupportDataMessage(tsChainId, adapterId))
+    throw Error(
+      `Adapter ${adapterId} does not support data message for tsChainId: ${tsChainId}`
+    );
+}
+
+export function doesAdapterSupportTokenMessage(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): boolean {
+  const isHub = isHubChain(tsChainId, TSCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && adapterId === AdapterType.WORMHOLE_DATA)
+  );
+}
+
+export function assertAdapterSupportsTokenMessage(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): void {
+  if (!doesAdapterSupportTokenMessage(tsChainId, adapterId))
+    throw Error(
+      `Adapter ${adapterId} does not support token message for tsChainId: ${tsChainId}`
+    );
+}
+
+export function doesAdapterSupportCrossChainToken(
+  crossChainToken: CrossChainTokenType,
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): boolean {
+  const isHub = isHubChain(tsChainId, TSCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && crossChainToken.adapters.includes(adapterId))
+  );
+}
+
+export function assertCrossChainTokenSupportedByAdapter(
+  crossChainToken: CrossChainTokenType,
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): void {
+  if (!doesAdapterSupportCrossChainToken(crossChainToken, tsChainId, adapterId))
+    throw Error(
+      `Adapter ${adapterId} does not support cross chain token: ${crossChainToken.address}`
+    );
+}
+
+export function assertAdapterSupportsCrossChainToken(
+  tsChainId: TSChainId,
+  crossChainToken: CrossChainTokenType,
+  adapterId: AdapterType
+): void {
+  assertAdapterSupportsTokenMessage(tsChainId, adapterId);
+  assertCrossChainTokenSupportedByAdapter(
+    crossChainToken,
+    tsChainId,
+    adapterId
+  );
+}
+
+export function doesAdapterSupportReceiverValue(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): boolean {
+  const isHub = isHubChain(tsChainId, TSCore.getSelectedNetwork());
+  return (
+    (isHub && adapterId === AdapterType.HUB) ||
+    (!isHub && adapterId === AdapterType.WORMHOLE_DATA)
+  );
+}
+
+export function assertAdapterSupportsReceiverValue(
+  tsChainId: TSChainId,
+  adapterId: AdapterType
+): void {
+  if (!doesAdapterSupportReceiverValue(tsChainId, adapterId))
+    throw Error(
+      `Adapter ${adapterId} does not support receiver value for tsChainId: ${tsChainId}`
+    );
+}
+
+function getSendTokenAdapterIds(tsTokenId: TSTokenId, network: NetworkType) {
+  const hubTokenData = getHubTokenData(tsTokenId, network);
+  if (hubTokenData.token.type == TokenType.CROSS_CHAIN)
+    return hubTokenData.token.adapters;
+  return DATA_ADAPTERS;
+}
+
+function getMessageAdapterIds(messageAdapterParams: MessageAdapterParams) {
+  const { network, messageAdapterParamType } = messageAdapterParams;
+  if (messageAdapterParamType === MessageAdapterParamsType.SendToken)
+    return getSendTokenAdapterIds(messageAdapterParams.tsTokenId, network);
+  return DATA_ADAPTERS;
+}
+
+function getReturnMessageAdapterIds({
+  tsTokenId,
+  network,
+}: ReceiveTokenMessageAdapterParams) {
+  return getSendTokenAdapterIds(tsTokenId, network);
+}
+
+export function getSupportedMessageAdapters<T extends MessageAdapterParams>(
+  params: T
+): SupportedMessageAdaptersMap[T['messageAdapterParamType']] {
+  const { messageAdapterParamType, sourceTsChainId, network } = params;
+  const spokeAdapterIds = getSpokeAdapterIds(sourceTsChainId, network);
+  const supportedAdapterIds = ensureNonEmpty(
+    getMessageAdapterIds(params).filter(intersect(spokeAdapterIds)),
+    `No supported adapters found for chain ${sourceTsChainId}`
+  );
+
+  switch (messageAdapterParamType) {
+    case MessageAdapterParamsType.SendToken:
+      return {
+        adapterIds: supportedAdapterIds,
+        returnAdapterIds: supportedAdapterIds,
+      } as SupportedMessageAdaptersMap[T['messageAdapterParamType']];
+
+    case MessageAdapterParamsType.ReceiveToken: {
+      const destSpokeAdapterIds = getSpokeAdapterIds(
+        params.destTsChainId,
+        network
+      );
+      const supportedReturnAdapterIds = ensureNonEmpty(
+        getReturnMessageAdapterIds(params).filter(
+          intersect(destSpokeAdapterIds)
+        ),
+        `No supported return adapters found for chain ${params.destTsChainId}`
+      );
+      return {
+        adapterIds: supportedAdapterIds,
+        returnAdapterIds: supportedReturnAdapterIds,
+      } as SupportedMessageAdaptersMap[T['messageAdapterParamType']];
+    }
+
+    case MessageAdapterParamsType.Data:
+      return {
+        adapterIds: supportedAdapterIds,
+        returnAdapterIds: [AdapterType.HUB],
+      } as SupportedMessageAdaptersMap[T['messageAdapterParamType']];
+
+    default:
+      return exhaustiveCheck(messageAdapterParamType);
+  }
+}

package/src/common/utils/address.ts

@@ -0,0 +1,50 @@
+import { getAddress, pad, sliceHex } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import { BYTES32_LENGTH, EVM_ADDRESS_BYTES_LENGTH } from '../constants/byte.js';
+import { ChainType } from '../types/chain.js';
+
+import type {
+  AddressType,
+  EvmAddress,
+  GenericAddress,
+} from '../types/address.js';
+
+export function getRandomGenericAddress(): GenericAddress {
+  return pad(privateKeyToAccount(generatePrivateKey()).address, {
+    size: BYTES32_LENGTH,
+  }).toLowerCase() as GenericAddress;
+}
+
+export function isGenericAddress(address: GenericAddress): boolean {
+  return address.length === 64 + 2;
+}
+
+export function convertToGenericAddress<T extends ChainType>(
+  address: AddressType<T>,
+  fromChainType: ChainType
+): GenericAddress {
+  switch (fromChainType) {
+    case ChainType.EVM:
+      return pad(address as EvmAddress, {
+        size: BYTES32_LENGTH,
+      }).toLowerCase() as GenericAddress;
+    default:
+      return exhaustiveCheck(fromChainType);
+  }
+}
+
+export function convertFromGenericAddress<T extends ChainType>(
+  address: GenericAddress,
+  toChainType: ChainType
+): AddressType<T> {
+  switch (toChainType) {
+    case ChainType.EVM:
+      return getAddress(
+        sliceHex(address, BYTES32_LENGTH - EVM_ADDRESS_BYTES_LENGTH)
+      ) as EvmAddress;
+    default:
+      return exhaustiveCheck(toChainType);
+  }
+}

package/src/common/utils/bytes.ts

@@ -0,0 +1,36 @@
+import { bytesToHex, pad, toHex } from 'viem';
+
+import type { Hex } from 'viem';
+
+export function getEmptyBytes(length: number): string {
+  return pad('0x', { size: length });
+}
+
+export function convertNumberToBytes(
+  num: number | bigint,
+  length: number
+): Hex {
+  // insert 0s at the beginning if data is smaller than length bytes
+  const buf = Buffer.alloc(length, 0);
+
+  // convert num to bytes
+  const hex = num.toString(16);
+  const isEven = hex.length % 2 === 0;
+  const bytes = Buffer.from(isEven ? hex : '0' + hex, 'hex');
+
+  // write bytes to fixed length buf
+  bytes.copy(buf, buf.length - bytes.length);
+  return toHex(buf);
+}
+
+export function convertStringToBytes(str: string): Hex {
+  return toHex('0x' + Buffer.from(str).toString('hex'));
+}
+
+export function convertBooleanToByte(bool: boolean): Hex {
+  return bool ? '0x01' : '0x00';
+}
+
+export function getRandomBytes(length: number): Hex {
+  return bytesToHex(crypto.getRandomValues(new Uint8Array(length)));
+}

package/src/common/utils/chain.ts

@@ -0,0 +1,163 @@
+import { getEvmSignerAddress } from '../../chains/evm/common/utils/chain.js';
+import {
+  getHubChainAdapterAddress,
+  isHubChain,
+} from '../../chains/evm/hub/utils/chain.js';
+import { exhaustiveCheck } from '../../utils/exhaustive-check.js';
+import { TS_CHAIN, SPOKE_CHAIN } from '../constants/chain.js';
+import { ChainType } from '../types/chain.js';
+
+import { convertToGenericAddress } from './address.js';
+
+import type { GenericAddress } from '../types/address.js';
+import type {
+  TSChain,
+  TSChainId,
+  NetworkType,
+  SpokeChain,
+} from '../types/chain.js';
+import type { TSChainSigner } from '../types/core.js';
+import type { AdapterType } from '../types/message.js';
+
+import type { TSTokenId, SpokeTokenData } from '../types/token.js';
+
+export function getTsChain(
+  tsChainId: TSChainId,
+  network: NetworkType
+): TSChain {
+  const tsChain = TS_CHAIN[network][tsChainId];
+  if (!tsChain)
+    throw new Error(`Townsq Chain not found for tsChainId: ${tsChainId}`);
+
+  return tsChain;
+}
+
+export function getTsChainsByNetwork(network: NetworkType): Array<TSChain> {
+  return Object.values(TS_CHAIN[network]);
+}
+
+export function getTsChainIdsByNetwork(
+  networkType: NetworkType
+): Array<TSChainId> {
+  return getTsChainsByNetwork(networkType).map(
+    (tsChain) => tsChain.tsChainId
+  );
+}
+
+export function isSpokeChainSupported(
+  tsChainId: TSChainId,
+  network: NetworkType
+): boolean {
+  return SPOKE_CHAIN[network][tsChainId] !== undefined;
+}
+
+export function assertSpokeChainSupported(
+  tsChainId: TSChainId,
+  network: NetworkType
+) {
+  if (!isSpokeChainSupported(tsChainId, network))
+    throw new Error(`Spoke chain is not supported for tsChainId: ${tsChainId}`);
+}
+
+export function getSpokeChain(
+  tsChainId: TSChainId,
+  network: NetworkType
+): SpokeChain {
+  const spokeChain = SPOKE_CHAIN[network][tsChainId];
+  if (!spokeChain)
+    throw new Error(`Spoke chain not found for tsChainId: ${tsChainId}`);
+
+  return spokeChain;
+}
+
+export function doesSpokeSupportTsToken(
+  spokeChain: SpokeChain,
+  tsTokenId: TSTokenId
+): boolean {
+  return spokeChain.tokens[tsTokenId] !== undefined;
+}
+
+export function getSpokeTokenData(
+  spokeChain: SpokeChain,
+  tsTokenId: TSTokenId
+): SpokeTokenData {
+  const tokenData = spokeChain.tokens[tsTokenId];
+  if (!tokenData)
+    throw new Error(`Spoke Token not found for tsTokenId: ${tsTokenId}`);
+
+  return tokenData;
+}
+
+export function isTsTokenSupported(
+  tsTokenId: TSTokenId,
+  tsChainId: TSChainId,
+  network: NetworkType
+): boolean {
+  const spokeChain = getSpokeChain(tsChainId, network);
+  return doesSpokeSupportTsToken(spokeChain, tsTokenId);
+}
+
+export function assertSpokeChainSupportTsToken(
+  tsChainId: TSChainId,
+  tsTokenId: TSTokenId,
+  network: NetworkType
+) {
+  if (!isTsTokenSupported(tsTokenId, tsChainId, network))
+    throw new Error(
+      `Townsq Token ${tsTokenId} is not supported on Townsq Chain ${tsChainId}`
+    );
+}
+
+export function getSpokeChainAdapterAddress(
+  tsChainId: TSChainId,
+  network: NetworkType,
+  adapterType: AdapterType
+): GenericAddress {
+  const spokeChain = getSpokeChain(tsChainId, network);
+  const { adapters } = spokeChain;
+  const adapterAddress = adapters[adapterType];
+  if (adapterAddress) return adapterAddress;
+  throw new Error(
+    `Adapter ${adapterType} not found for spoke chain ${tsChainId}`
+  );
+}
+
+export function getAdapterAddress(
+  tsChainId: TSChainId,
+  network: NetworkType,
+  adapterType: AdapterType
+) {
+  if (isHubChain(tsChainId, network))
+    return getHubChainAdapterAddress(network, adapterType);
+  return getSpokeChainAdapterAddress(tsChainId, network, adapterType);
+}
+
+export function getSpokeChainBridgeRouterAddress(spokeChain: SpokeChain) {
+  const { messageDispatcherAddress } = spokeChain;
+  return messageDispatcherAddress;
+}
+
+export function getSignerGenericAddress(
+  tsChainSigner: TSChainSigner
+): GenericAddress {
+  const chainType = tsChainSigner.chainType;
+  switch (chainType) {
+    case ChainType.EVM:
+      return convertToGenericAddress(
+        getEvmSignerAddress(tsChainSigner.signer),
+        chainType
+      );
+    default:
+      return exhaustiveCheck(chainType);
+  }
+}
+
+export function assertHubChainSelected(
+  tsChainId: TSChainId,
+  network: NetworkType
+) {
+  if (!isHubChain(tsChainId, network))
+    throw new Error(
+      `Wrong chain selected: ${tsChainId}. Expected Hub chain`
+    );
+}

package/src/common/utils/formulae.ts

@@ -0,0 +1,270 @@
+import * as dn from 'dnum';
+
+import { SECONDS_IN_YEAR, expBySquaring, unixTime } from './math-lib.js';
+
+import type { Dnum } from 'dnum';
+
+export function calcPeriodNumber(offset: bigint, length: bigint): bigint {
+  return (BigInt(unixTime()) + offset) / length;
+}
+
+export function calcNextPeriodReset(
+  periodNumber: bigint,
+  offset: bigint,
+  length: bigint
+): bigint {
+  return (periodNumber + BigInt(1)) * length - offset;
+}
+
+export function calcOverallBorrowInterestRate(
+  totalVarDebt: bigint,
+  totalStableDebt: bigint,
+  variableBorInterestRate: Dnum,
+  avgStableBorInterestRate: Dnum
+): Dnum {
+  const totalDebt = totalVarDebt + totalStableDebt;
+  if (totalDebt === 0n) return dn.from(0, 18);
+
+  return dn.div(
+    dn.add(
+      dn.mul(totalVarDebt, variableBorInterestRate, {
+        rounding: 'ROUND_DOWN',
+        decimals: 0,
+      }),
+      dn.mul(totalStableDebt, avgStableBorInterestRate, {
+        rounding: 'ROUND_DOWN',
+        decimals: 0,
+      })
+    ),
+    totalDebt,
+    { rounding: 'ROUND_DOWN', decimals: 18 }
+  );
+}
+
+export function calcDepositInterestIndex(
+  dirt1: Dnum,
+  diit1: Dnum,
+  latestUpdate: bigint,
+  lastTimestamp = BigInt(unixTime())
+): Dnum {
+  const dt = lastTimestamp - latestUpdate;
+  return dn.mul(
+    diit1,
+    dn.add(
+      dn.from(1, 18),
+      dn.div(dn.mul(dirt1, dt, { rounding: 'ROUND_DOWN' }), SECONDS_IN_YEAR, {
+        rounding: 'ROUND_DOWN',
+      })
+    ),
+    { rounding: 'ROUND_DOWN' }
+  );
+}
+
+export function calcBorrowInterestIndex(
+  birt1: Dnum,
+  biit1: Dnum,
+  latestUpdate: bigint,
+  lastTimestamp = BigInt(unixTime())
+): Dnum {
+  const dt = lastTimestamp - latestUpdate;
+  return dn.mul(
+    biit1,
+    expBySquaring(
+      dn.add(
+        dn.from(1, 18),
+        dn.div(birt1, SECONDS_IN_YEAR, { rounding: 'ROUND_DOWN' })
+      ),
+      dt
+    ),
+    { rounding: 'ROUND_DOWN' }
+  );
+}
+
+export function calcRetention(
+  actualRetained: bigint,
+  totalDebt: bigint,
+  overallBorrowInterestRate: Dnum,
+  retentionRate: Dnum,
+  latestUpdate: bigint,
+  lastTimestamp = BigInt(unixTime())
+): bigint {
+  const dt = lastTimestamp - latestUpdate;
+
+  const [retainedDelta] = dn.div(
+    dn.mul(
+      dn.mul(
+        dn.mul(totalDebt, overallBorrowInterestRate, {
+          rounding: 'ROUND_DOWN',
+          decimals: 0,
+        }),
+        retentionRate,
+        {
+          rounding: 'ROUND_DOWN',
+          decimals: 0,
+        }
+      ),
+      dt,
+      { rounding: 'ROUND_DOWN' }
+    ),
+    SECONDS_IN_YEAR,
+    {
+      rounding: 'ROUND_DOWN',
+    }
+  );
+  return actualRetained + retainedDelta;
+}
+
+export function calcRewardIndex(
+  used: bigint,
+  ma: bigint,
+  rit1: Dnum,
+  rs: Dnum,
+  latestUpdate: bigint
+): Dnum {
+  if (used <= ma) return rit1;
+  const dt = BigInt(unixTime()) - latestUpdate;
+  return dn.add(
+    rit1,
+    dn.div(dn.mul(rs, dt, { rounding: 'ROUND_DOWN' }), used, {
+      rounding: 'ROUND_DOWN',
+    })
+  );
+}
+
+export function calcAccruedRewards(
+  amount: bigint,
+  rit: Dnum,
+  ritn1: Dnum
+): bigint {
+  const [accruedRewards] = dn.mul([amount, 0], dn.sub(rit, ritn1), {
+    rounding: 'ROUND_DOWN',
+  });
+  return accruedRewards;
+}
+
+export function toFAmount(underlyingAmount: bigint, diit: Dnum): bigint {
+  const [fAmount] = dn.div([underlyingAmount, 0], diit, {
+    rounding: 'ROUND_DOWN',
+  });
+  return fAmount;
+}
+
+export function toUnderlyingAmount(fAmount: bigint, diit: Dnum): bigint {
+  const [underlyingAmount] = dn.mul([fAmount, 0], diit, {
+    rounding: 'ROUND_DOWN',
+  });
+  return underlyingAmount;
+}
+
+export function calcAssetDollarValue(
+  amount: bigint,
+  tokenPrice: Dnum,
+  tokenDecimals: number
+): Dnum {
+  return dn.mul(tokenPrice, [amount, tokenDecimals], {
+    rounding: 'ROUND_DOWN',
+  });
+}
+
+export function calcCollateralAssetLoanValue(
+  amount: bigint,
+  tokenPrice: Dnum,
+  tokenDecimals: number,
+  collateralFactor: Dnum
+): Dnum {
+  return dn.mul(
+    calcAssetDollarValue(amount, tokenPrice, tokenDecimals),
+    collateralFactor,
+    {
+      rounding: 'ROUND_DOWN',
+      decimals: 8,
+    }
+  );
+}
+
+export function calcBorrowAssetLoanValue(
+  amount: bigint,
+  tokenPrice: Dnum,
+  tokenDecimals: number,
+  borrowFactor: Dnum
+): Dnum {
+  return dn.mul(
+    calcAssetDollarValue(amount, tokenPrice, tokenDecimals),
+    borrowFactor,
+    {
+      rounding: 'ROUND_UP',
+      decimals: 8,
+    }
+  );
+}
+
+export function calcBorrowBalance(
+  bbtn1: bigint,
+  biit: Dnum,
+  biitn1: Dnum
+): bigint {
+  const [borrowBalance] = dn.mul(
+    [bbtn1, 0],
+    dn.div(biit, biitn1, { rounding: 'ROUND_UP' }),
+    {
+      rounding: 'ROUND_UP',
+    }
+  );
+  return borrowBalance;
+}
+
+export function calcStableInterestRate(
+  bbt: bigint,
+  amount: bigint,
+  sbirtn1: Dnum,
+  sbirt1: Dnum
+): Dnum {
+  return dn.div(
+    dn.add(dn.mul(sbirtn1, [bbt, 0]), dn.mul(sbirt1, [amount, 0])),
+    dn.add([bbt, 0], [amount, 0])
+  );
+}
+
+export function calcLtvRatio(
+  totalBorrowBalanceValue: Dnum,
+  totalCollateralBalanceValue: Dnum
+): Dnum {
+  const [, decimals] = totalBorrowBalanceValue;
+  if (dn.equal(totalCollateralBalanceValue, 0)) return dn.from(0, decimals);
+  return dn.div(totalBorrowBalanceValue, totalCollateralBalanceValue, {
+    rounding: 'ROUND_UP',
+  });
+}
+
+export function calcBorrowUtilisationRatio(
+  totalEffectiveBorrowBalanceValue: Dnum,
+  totalEffectiveCollateralBalanceValue: Dnum
+): Dnum {
+  const [, decimals] = totalEffectiveBorrowBalanceValue;
+  if (dn.equal(totalEffectiveCollateralBalanceValue, 0))
+    return dn.from(0, decimals);
+  return dn.div(
+    totalEffectiveBorrowBalanceValue,
+    totalEffectiveCollateralBalanceValue,
+    { rounding: 'ROUND_UP' }
+  );
+}
+
+export function calcLiquidationMargin(
+  totalEffectiveBorrowBalanceValue: Dnum,
+  totalEffectiveCollateralBalanceValue: Dnum
+): Dnum {
+  const [, decimals] = totalEffectiveBorrowBalanceValue;
+  if (dn.equal(totalEffectiveCollateralBalanceValue, 0))
+    return dn.from(0, decimals);
+  return dn.div(
+    dn.sub(
+      totalEffectiveCollateralBalanceValue,
+      totalEffectiveBorrowBalanceValue
+    ),
+    totalEffectiveCollateralBalanceValue,
+    {
+      rounding: 'ROUND_DOWN',
+    }
+  );
+}