@townsq/mm-sdk 1.0.1

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

@@ -0,0 +1,131 @@
+import { multicall } from 'viem/actions';
+
+import { getHubChain } from '../utils/chain.js';
+import {
+  getNodeManagerContract,
+  getPriceFeedControllerContract,
+} from '../utils/contract.js';
+
+import type { NetworkType } from '../../../../common/types/chain.js';
+import type { NodeManagerAbi } from '../constants/abi/node-manager-abi.js';
+import type { PriceFeedControllerAbi } from '../constants/abi/oracle-manager-abi.js';
+import type {
+  OracleNode,
+  OracleNodePrice,
+  OracleNodePrices,
+  OraclePrice,
+  OraclePrices,
+} from '../types/oracle.js';
+import type { HubTokenData } from '../types/token.js';
+import type {
+  Client,
+  ContractFunctionParameters,
+  ReadContractReturnType,
+} from 'viem';
+
+export async function getOraclePrice(
+  provider: Client,
+  network: NetworkType,
+  poolId: number,
+  blockNumber?: bigint
+): Promise<OraclePrice> {
+  const hubChain = getHubChain(network);
+
+  const priceFeedController = getPriceFeedControllerContract(
+    provider,
+    hubChain.priceFeedControllerAddress
+  );
+
+  const { price, decimals } = await priceFeedController.read.processPriceFeed(
+    [poolId],
+    { blockNumber }
+  );
+  return { price: [price, 18], decimals };
+}
+
+export async function getOraclePrices(
+  provider: Client,
+  network: NetworkType,
+  tokens: Array<HubTokenData>,
+  blockNumber?: bigint
+): Promise<OraclePrices> {
+  const hubChain = getHubChain(network);
+  const priceFeedController = getPriceFeedControllerContract(
+    provider,
+    hubChain.priceFeedControllerAddress
+  );
+
+  const processPriceFeeds: Array<ContractFunctionParameters> = tokens.map(
+    ({ poolId }) => ({
+      address: priceFeedController.address,
+      abi: priceFeedController.abi,
+      functionName: 'processPriceFeed',
+      args: [poolId],
+    })
+  );
+
+  const priceFeeds = (await multicall(provider, {
+    contracts: processPriceFeeds,
+    allowFailure: false,
+    blockNumber,
+  })) as Array<
+    ReadContractReturnType<typeof PriceFeedControllerAbi, 'processPriceFeed'>
+  >;
+
+  const oraclePrices: OraclePrices = {};
+  for (const [i, { price, decimals }] of priceFeeds.entries()) {
+    const { TsTokenId } = tokens[i];
+    oraclePrices[TsTokenId] = { price: [price, 18], decimals };
+  }
+  return oraclePrices;
+}
+
+export async function getNodePrice(
+  provider: Client,
+  network: NetworkType,
+  oracleNode: OracleNode
+): Promise<OracleNodePrice> {
+  const hubChain = getHubChain(network);
+
+  const nodeManager = getNodeManagerContract(
+    provider,
+    hubChain.nodeManagerAddress
+  );
+
+  const { nodeId, decimals } = oracleNode;
+  const { price, timestamp } = await nodeManager.read.process([nodeId]);
+  return { price: [price, 18], decimals, timestamp };
+}
+
+export async function getNodePrices(
+  provider: Client,
+  network: NetworkType,
+  oracleNodes: Array<OracleNode>
+): Promise<OracleNodePrices> {
+  const hubChain = getHubChain(network);
+  const nodeManager = getNodeManagerContract(
+    provider,
+    hubChain.nodeManagerAddress
+  );
+
+  const processPriceFeeds: Array<ContractFunctionParameters> = oracleNodes.map(
+    ({ nodeId }) => ({
+      address: nodeManager.address,
+      abi: nodeManager.abi,
+      functionName: 'process',
+      args: [nodeId],
+    })
+  );
+
+  const priceFeeds = (await multicall(provider, {
+    contracts: processPriceFeeds,
+    allowFailure: false,
+  })) as Array<ReadContractReturnType<typeof NodeManagerAbi, 'process'>>;
+
+  const oracleNodePrices: OracleNodePrices = {};
+  for (const [i, { price, timestamp }] of priceFeeds.entries()) {
+    const { nodeId, decimals } = oracleNodes[i];
+    oracleNodePrices[nodeId] = { price: [price, 18], decimals, timestamp };
+  }
+  return oracleNodePrices;
+}

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

@@ -0,0 +1,241 @@
+import { multicall } from 'viem/actions';
+
+import {
+  calcBorrowInterestIndex,
+  calcDepositInterestIndex,
+  calcOverallBorrowInterestRate,
+  calcRetention,
+} from '../../../../common/utils/formulae.js';
+import {
+  compoundEveryHour,
+  compoundEverySecond,
+  unixTime,
+} from '../../../../common/utils/math-lib.js';
+import { getBlockTimestamp } from '../../common/utils/chain.js';
+import { getHubTokenData } from '../utils/chain.js';
+import { getHubPoolContract } from '../utils/contract.js';
+
+import type {
+  EvmAddress,
+  GenericAddress,
+} from '../../../../common/types/address.js';
+import type { NetworkType } from '../../../../common/types/chain.js';
+import type { TSTokenId } from '../../../../common/types/token.js';
+import type { PoolInfo } from '../types/pool.js';
+import type { Client } from 'viem';
+
+export async function getPoolInfo(
+  provider: Client,
+  network: NetworkType,
+  tsTokenId: TSTokenId,
+  blockNumber?: bigint
+): Promise<PoolInfo> {
+  const {
+    poolAddress,
+    token: { decimals: tokenDecimals },
+  } = getHubTokenData(tsTokenId, network);
+  const hubPool = getHubPoolContract(provider, poolAddress);
+
+  // get pool data
+  const [
+    poolId,
+    lastUpdateTimestamp,
+    feeData,
+    depositData,
+    variableBorrowData,
+    stableBorrowData,
+    capsData,
+    configData,
+    tsTokenCirculatingSupply,
+  ] = await multicall(provider, {
+    contracts: [
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getPoolId',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getLastUpdateTimestamp',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getFeeData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getDepositData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getVariableBorrowData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getStableBorrowData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getCapsData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'getConfigData',
+      },
+      {
+        address: hubPool.address,
+        abi: hubPool.abi,
+        functionName: 'totalSupply',
+      },
+    ],
+    allowFailure: false,
+    blockNumber,
+  });
+
+  const lastTimestamp = blockNumber
+    ? await getBlockTimestamp(provider, blockNumber)
+    : BigInt(unixTime());
+
+  const {
+    flashLoanFee,
+    retentionRate,
+    tsTokenFeeRecipient,
+    tokenFeeClaimer,
+    totalRetainedAmount: actualRetained,
+    tokenFeeRecipient,
+  } = feeData;
+  const {
+    optimalUtilisationRatio,
+    totalAmount: depositTotalAmount,
+    interestRate: depositInterestRate,
+    interestIndex: oldDepositInterestIndex,
+  } = depositData;
+  const {
+    vr0,
+    vr1,
+    vr2,
+    totalAmount: variableBorrowTotalAmount,
+    interestRate: variableBorrowInterestRate,
+    interestIndex: oldVariableBorrowInterestsIndex,
+  } = variableBorrowData;
+  const {
+    sr0,
+    sr1,
+    sr2,
+    sr3,
+    optimalStableToTotalDebtRatio,
+    increaseBorrowBalanceUtilisationRatio,
+    increaseBorrowBalanceDepositInterestRate,
+    decreaseBorrowBalanceDelta,
+    totalAmount: stableBorrowTotalAmount,
+    interestRate: stableBorrowInterestRate,
+    averageInterestRate: stableBorrowAverageInterestRate,
+  } = stableBorrowData;
+  const {
+    deposit: depositCap,
+    borrow: borrowCap,
+    stableBorrowPercentage: stableBorrowPercentageCap,
+  } = capsData;
+  const {
+    deprecated,
+    stableBorrowSupported,
+    canMintTsToken,
+    flashLoanSupported,
+  } = configData;
+
+  // build pool info
+  return {
+    tsTokenId,
+    poolId,
+    tokenDecimals,
+    feeData: {
+      flashLoanFee: [BigInt(flashLoanFee), 6],
+      retentionRate: [BigInt(retentionRate), 6],
+      totalRetainedAmount: calcRetention(
+        actualRetained,
+        variableBorrowTotalAmount + stableBorrowTotalAmount,
+        calcOverallBorrowInterestRate(
+          variableBorrowTotalAmount,
+          stableBorrowTotalAmount,
+          [variableBorrowInterestRate, 18],
+          [stableBorrowAverageInterestRate, 18]
+        ),
+        [BigInt(retentionRate), 6],
+        lastUpdateTimestamp,
+        lastTimestamp
+      ),
+      tsTokenFeeRecipient: tsTokenFeeRecipient as EvmAddress,
+      tokenFeeClaimer: tokenFeeClaimer as EvmAddress,
+      tokenFeeRecipient: tokenFeeRecipient as GenericAddress,
+    },
+    depositData: {
+      optimalUtilisationRatio: [BigInt(optimalUtilisationRatio), 4],
+      totalAmount: depositTotalAmount,
+      interestRate: [depositInterestRate, 18],
+      interestYield: compoundEveryHour([depositInterestRate, 18]),
+      interestIndex: calcDepositInterestIndex(
+        [depositInterestRate, 18],
+        [oldDepositInterestIndex, 18],
+        lastUpdateTimestamp,
+        lastTimestamp
+      ),
+    },
+    variableBorrowData: {
+      vr0: [BigInt(vr0), 6],
+      vr1: [BigInt(vr1), 6],
+      vr2: [BigInt(vr2), 6],
+      totalAmount: variableBorrowTotalAmount,
+      interestRate: [variableBorrowInterestRate, 18],
+      interestYield: compoundEverySecond([variableBorrowInterestRate, 18]),
+      interestIndex: calcBorrowInterestIndex(
+        [variableBorrowInterestRate, 18],
+        [oldVariableBorrowInterestsIndex, 18],
+        lastUpdateTimestamp,
+        lastTimestamp
+      ),
+    },
+    stableBorrowData: {
+      sr0: [BigInt(sr0), 6],
+      sr1: [BigInt(sr1), 6],
+      sr2: [BigInt(sr2), 6],
+      sr3: [BigInt(sr3), 6],
+      optimalStableToTotalDebtRatio: [BigInt(optimalStableToTotalDebtRatio), 4],
+      increaseBorrowBalanceUtilisationRatio: [
+        BigInt(increaseBorrowBalanceUtilisationRatio),
+        4,
+      ],
+      increaseBorrowBalanceDepositInterestRate: [
+        BigInt(increaseBorrowBalanceDepositInterestRate),
+        4,
+      ],
+      decreaseBorrowBalanceDelta: [BigInt(decreaseBorrowBalanceDelta), 4],
+      totalAmount: stableBorrowTotalAmount,
+      interestRate: [stableBorrowInterestRate, 18],
+      interestYield: compoundEverySecond([stableBorrowInterestRate, 18]),
+      averageInterestRate: [stableBorrowAverageInterestRate, 18],
+      averageInterestYield: compoundEverySecond([
+        stableBorrowAverageInterestRate,
+        18,
+      ]),
+    },
+    capsData: {
+      deposit: BigInt(depositCap),
+      borrow: BigInt(borrowCap),
+      stableBorrowPercentage: [BigInt(stableBorrowPercentageCap), 18],
+    },
+    configData: {
+      deprecated,
+      stableBorrowSupported,
+      canMintTsToken,
+      flashLoanSupported,
+    },
+    tsTokenCirculatingSupply,
+  };
+}

package/src/chains/evm/hub/types/account.ts

@@ -0,0 +1,30 @@
+import type { GenericAddress } from '../../../../common/types/address.js';
+import type { TSChainId } from '../../../../common/types/chain.js';
+import type { AccountId } from '../../../../common/types/lending.js';
+import type {
+  GetEventParams,
+  GetReadContractReturnType,
+} from '../../common/types/contract.js';
+import type { AccountControllerAbi } from '../constants/abi/account-manager-abi.js';
+
+export type AccountInfo = {
+  registered: Map<TSChainId, GenericAddress>;
+  invited: Map<TSChainId, GenericAddress>;
+};
+
+export type AccountIdByAddress = Array<{
+  accountId: AccountId;
+  tsChainId: TSChainId;
+}>;
+
+export type InviteAddressEventParams = GetEventParams & {
+  accountController: GetReadContractReturnType<typeof AccountControllerAbi>;
+  address: GenericAddress;
+  tsChainId?: TSChainId;
+};
+
+export type AcceptInviteAddressEventParams = GetEventParams & {
+  accountController: GetReadContractReturnType<typeof AccountControllerAbi>;
+  address: GenericAddress;
+  tsChainId?: TSChainId;
+};

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

@@ -0,0 +1,22 @@
+import type { HubTokenData } from './token.js';
+import type { GenericAddress } from '../../../../common/types/address.js';
+import type { ITSChain } from '../../../../common/types/chain.js';
+import type { AdapterType } from '../../../../common/types/message.js';
+import type { TSTokenId } from '../../../../common/types/token.js';
+
+export type HubRewardsMap = {
+  bridgeRouterAddress: GenericAddress;
+  adapters: Partial<Record<AdapterType, GenericAddress>>;
+};
+
+export type HubChain = {
+  hubAddress: GenericAddress;
+  hubMessageDispatcher: GenericAddress;
+  adapters: Record<AdapterType, GenericAddress>;
+  nodeManagerAddress: GenericAddress;
+  priceFeedControllerAddress: GenericAddress;
+  spokeControllerAddress: GenericAddress;
+  accountControllerAddress: GenericAddress;
+  loanControllerAddress: GenericAddress;
+  tokens: Partial<Record<TSTokenId, HubTokenData>>;
+} & ITSChain;

package/src/chains/evm/hub/types/loan.ts

@@ -0,0 +1,188 @@
+import type { OraclePrice } from './oracle.js';
+import type { PoolInfo } from './pool.js';
+import type {
+  AccountId,
+  LoanId,
+  LoanTypeId,
+} from '../../../../common/types/lending.js';
+import type { TSTokenId } from '../../../../common/types/token.js';
+import type {
+  GetEventParams,
+  GetReadContractReturnType,
+} from '../../common/types/contract.js';
+import type { LoanControllerAbi } from '../constants/abi/loan-manager-abi.js';
+import type { Dnum } from 'dnum';
+import type { ReadContractReturnType } from 'viem';
+
+export type LoanPoolInfo = {
+  tsTokenId: TSTokenId;
+  poolId: number;
+  collateralUsed: bigint; // in f token
+  borrowUsed: bigint; // in token
+  collateralCap: bigint; // $ amount
+  borrowCap: bigint; // $ amount
+  collateralFactor: Dnum;
+  borrowFactor: Dnum;
+  liquidationBonus: Dnum;
+  liquidationFee: Dnum;
+  isDeprecated: boolean;
+  reward: {
+    minimumAmount: bigint; // in token
+    collateralSpeed: Dnum;
+    borrowSpeed: Dnum;
+    collateralRewardIndex: Dnum;
+    borrowRewardIndex: Dnum;
+  };
+};
+
+export type LoanTypeInfo = {
+  loanTypeId: LoanTypeId;
+  deprecated: boolean;
+  loanTargetHealth: Dnum;
+  pools: Partial<Record<TSTokenId, LoanPoolInfo>>;
+};
+
+export type PoolsPoints = {
+  collateral: bigint;
+  borrow: bigint;
+  interestPaid: bigint;
+};
+
+export type UserPoints = {
+  accountId: AccountId;
+  poolsPoints: Partial<Record<TSTokenId, PoolsPoints>>;
+};
+
+export type UserLoanInfoCollateral = {
+  tsTokenId: TSTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  oraclePrice: OraclePrice;
+  collateralFactor: Dnum;
+  fTokenBalance: bigint;
+  tokenBalance: bigint;
+  balanceValue: Dnum;
+  effectiveBalanceValue: Dnum;
+  interestRate: Dnum;
+  interestYield: Dnum;
+};
+
+export type UserLoanInfoBorrow = {
+  tsTokenId: TSTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  oraclePrice: OraclePrice;
+  isStable: boolean;
+  borrowFactor: Dnum;
+  borrowedAmount: bigint;
+  borrowedAmountValue: Dnum;
+  borrowBalance: bigint;
+  borrowBalanceValue: Dnum;
+  effectiveBorrowBalanceValue: Dnum;
+  accruedInterest: bigint;
+  accruedInterestValue: Dnum;
+  interestRate: Dnum;
+  interestYield: Dnum;
+};
+
+export type UserLoanInfo = {
+  loanId: LoanId;
+  loanTypeId: LoanTypeId;
+  accountId: AccountId;
+  collaterals: Partial<Record<TSTokenId, UserLoanInfoCollateral>>;
+  borrows: Partial<Record<TSTokenId, UserLoanInfoBorrow>>;
+  netRate: Dnum;
+  netYield: Dnum;
+  totalCollateralBalanceValue: Dnum;
+  totalBorrowedAmountValue: Dnum;
+  totalBorrowBalanceValue: Dnum;
+  totalEffectiveCollateralBalanceValue: Dnum;
+  totalEffectiveBorrowBalanceValue: Dnum;
+  loanToValueRatio: Dnum;
+  borrowUtilisationRatio: Dnum;
+  liquidationMargin: Dnum;
+};
+
+export type AssetsAdditionalInterest = Partial<
+  Record<
+    TSTokenId,
+    {
+      additionalRate: Dnum;
+      additionalYield: Dnum;
+    }
+  >
+>;
+
+export type CreateUserLoanEventParams = GetEventParams & {
+  loanController: GetReadContractReturnType<typeof LoanControllerAbi>;
+  accountId: AccountId;
+  loanTypeIds?: Array<LoanTypeId>;
+};
+
+export type DeleteUserLoanEventParams = GetEventParams & {
+  loanController: GetReadContractReturnType<typeof LoanControllerAbi>;
+  accountId: AccountId;
+};
+
+export type LoanControllerUserLoanAbi = ReadContractReturnType<
+  typeof LoanControllerAbi,
+  'retrieveUserLoan'
+>;
+
+export type LoanControllerUserLoanCollateral = LoanControllerUserLoanAbi[4][0];
+export type LoanControllerUserLoanBorrow = LoanControllerUserLoanAbi[5][0];
+
+export type LoanControllerUserLoan = {
+  accountId: AccountId;
+  loanTypeId: LoanTypeId;
+  colPools: Array<number>;
+  borPools: Array<number>;
+  userLoanCollateral: Array<LoanControllerUserLoanCollateral>;
+  userLoanBorrow: Array<LoanControllerUserLoanBorrow>;
+};
+
+export enum LoanChangeType {
+  AddCollateral,
+  ReduceCollateral,
+  Borrow,
+  Repay,
+  SwitchBorrowType,
+}
+
+type LoanBaseChange = {
+  type: LoanChangeType;
+  poolInfo: PoolInfo;
+};
+
+type LoanAddCollateralChange = LoanBaseChange & {
+  type: LoanChangeType.AddCollateral;
+  tsTokenAmount: bigint;
+};
+
+type LoanReduceCollateralChange = LoanBaseChange & {
+  type: LoanChangeType.ReduceCollateral;
+  tsTokenAmount: bigint;
+};
+
+type LoanBorrowChange = LoanBaseChange & {
+  type: LoanChangeType.Borrow;
+  tokenAmount: bigint;
+  isStable: boolean;
+};
+
+type LoanRepayChange = LoanBaseChange & {
+  type: LoanChangeType.Repay;
+  tokenAmount: bigint;
+};
+
+type LoanSwitchBorrowTypeChange = LoanBaseChange & {
+  type: LoanChangeType.SwitchBorrowType;
+  isSwitchingToStable: boolean;
+};
+
+export type LoanChange =
+  | LoanAddCollateralChange
+  | LoanReduceCollateralChange
+  | LoanBorrowChange
+  | LoanRepayChange
+  | LoanSwitchBorrowTypeChange;

package/src/chains/evm/hub/types/oracle.ts

@@ -0,0 +1,25 @@
+import type { Branded } from "../../../../common/types/brand.js";
+import type { TSTokenId } from "../../../../common/types/token.js";
+import type { Dnum } from "dnum";
+
+export type NodeId = Branded<`0x${string}`, "NodeId">;
+
+export type OracleNode = {
+  nodeId: NodeId;
+  decimals: number;
+};
+
+export type OracleNodePrice = {
+  price: Dnum;
+  decimals: number;
+  timestamp: bigint;
+};
+
+export type OracleNodePrices = Partial<Record<NodeId, OracleNodePrice>>;
+
+export type OraclePrice = {
+  price: Dnum;
+  decimals: number;
+};
+
+export type OraclePrices = Partial<Record<TSTokenId, OraclePrice>>;

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

@@ -0,0 +1,75 @@
+import type {
+  EvmAddress,
+  GenericAddress,
+} from '../../../../common/types/address.js';
+import type { TSTokenId } from '../../../../common/types/token.js';
+import type { Dnum } from 'dnum';
+
+type FeeData = {
+  flashLoanFee: Dnum;
+  retentionRate: Dnum;
+  tsTokenFeeRecipient: EvmAddress;
+  tokenFeeClaimer: EvmAddress;
+  totalRetainedAmount: bigint;
+  tokenFeeRecipient: GenericAddress;
+};
+
+type DepositData = {
+  optimalUtilisationRatio: Dnum;
+  totalAmount: bigint;
+  interestRate: Dnum;
+  interestYield: Dnum;
+  interestIndex: Dnum;
+};
+
+type VariableBorrowData = {
+  vr0: Dnum;
+  vr1: Dnum;
+  vr2: Dnum;
+  totalAmount: bigint;
+  interestRate: Dnum;
+  interestYield: Dnum;
+  interestIndex: Dnum;
+};
+
+type StableBorrowData = {
+  sr0: Dnum;
+  sr1: Dnum;
+  sr2: Dnum;
+  sr3: Dnum;
+  optimalStableToTotalDebtRatio: Dnum;
+  increaseBorrowBalanceUtilisationRatio: Dnum;
+  increaseBorrowBalanceDepositInterestRate: Dnum;
+  decreaseBorrowBalanceDelta: Dnum;
+  totalAmount: bigint;
+  interestRate: Dnum;
+  interestYield: Dnum;
+  averageInterestRate: Dnum;
+  averageInterestYield: Dnum;
+};
+
+type CapsData = {
+  deposit: bigint; // $ amount
+  borrow: bigint; // $ amount
+  stableBorrowPercentage: Dnum;
+};
+
+type ConfigData = {
+  deprecated: boolean;
+  stableBorrowSupported: boolean;
+  canMintTsToken: boolean;
+  flashLoanSupported: boolean;
+};
+
+export type PoolInfo = {
+  tsTokenId: TSTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  feeData: FeeData;
+  depositData: DepositData;
+  variableBorrowData: VariableBorrowData;
+  stableBorrowData: StableBorrowData;
+  capsData: CapsData;
+  configData: ConfigData;
+  tsTokenCirculatingSupply: bigint;
+};