@townsq/mm-sdk 1.0.1

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

@@ -0,0 +1,10 @@
+import type { GenericAddress } from "../../../../common/types/address.js";
+import type { LoanTypeId } from "../../../../common/types/lending.js";
+import type { TsHubTokenType, ITokenData } from "../../../../common/types/token.js";
+
+export type HubTokenData = {
+  poolId: number;
+  poolAddress: GenericAddress;
+  token: TsHubTokenType;
+  supportedLoanTypes: Set<LoanTypeId>;
+} & ITokenData;

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

@@ -0,0 +1,78 @@
+import { HUB_CHAIN } from '../constants/chain.js';
+
+import type { GenericAddress } from '../../../../common/types/address.js';
+import type { TSChainId, NetworkType } from '../../../../common/types/chain.js';
+import type { LoanTypeId } from '../../../../common/types/lending.js';
+import type { AdapterType } from '../../../../common/types/message.js';
+
+import type { TSTokenId } from '../../../../common/types/token.js';
+import type { HubChain } from '../types/chain.js';
+import type { HubTokenData } from '../types/token.js';
+
+export function isHubChain(
+  tsChainId: TSChainId,
+  network: NetworkType
+): boolean {
+  return HUB_CHAIN[network].tsChainId === tsChainId;
+}
+
+export function getHubChain(network: NetworkType): HubChain {
+  return HUB_CHAIN[network];
+}
+
+export function getHubTokensData(
+  network: NetworkType
+): Partial<Record<TSTokenId, HubTokenData>> {
+  return HUB_CHAIN[network].tokens;
+}
+
+export function getHubTokenData(
+  tsTokenId: TSTokenId,
+  network: NetworkType
+): HubTokenData {
+  const token = HUB_CHAIN[network].tokens[tsTokenId];
+  if (!token)
+    throw new Error(`Hub token not found for tsTokenId: ${tsTokenId}`);
+  return token;
+}
+
+export function isLoanTypeSupported(
+  loanType: LoanTypeId,
+  tsTokenId: TSTokenId,
+  network: NetworkType
+): boolean {
+  const token = getHubTokenData(tsTokenId, network);
+  return token.supportedLoanTypes.has(loanType);
+}
+
+export function assertLoanTypeSupported(
+  loanType: LoanTypeId,
+  tsTokenId: TSTokenId,
+  network: NetworkType
+): void {
+  if (!isLoanTypeSupported(loanType, tsTokenId, network))
+    throw new Error(
+      `Loan type ${loanType} is not supported for tsTokenId: ${tsTokenId}`
+    );
+}
+
+export function getHubChainAdapterAddress(
+  network: NetworkType,
+  adapterType: AdapterType
+) {
+  const hubChain = getHubChain(network);
+  const { adapters } = hubChain;
+  const adapterAddress = adapters[adapterType];
+  if (adapterAddress) return adapterAddress;
+  throw new Error(
+    `Adapter ${adapterType} not found for hub chain ${hubChain.tsChainId}`
+  );
+}
+
+export function getHubChainBridgeRouterAddress(
+  hubChain: HubChain,
+  isRewards = false
+) {
+  const { hubMessageDispatcher } = hubChain;
+  return hubMessageDispatcher;
+}

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

@@ -0,0 +1,178 @@
+import { getContract } from 'viem';
+
+import { ChainType } from '../../../../common/types/chain.js';
+import { convertFromGenericAddress } from '../../../../common/utils/address.js';
+import { AccountControllerAbi } from '../constants/abi/account-manager-abi.js';
+import { BridgeRouterHubAbi } from '../constants/abi/bridge-router-hub-abi.js';
+import { HubAbi } from '../constants/abi/hub-abi.js';
+import { HubPoolAbi } from '../constants/abi/hub-pool-abi.js';
+import { HubRewardsV1Abi } from '../constants/abi/hub-rewards-v1-abi.js';
+import { HubRewardsV2Abi } from '../constants/abi/hub-rewards-v2-abi.js';
+import { LoanControllerAbi } from '../constants/abi/loan-manager-abi.js';
+import { NodeManagerAbi } from '../constants/abi/node-manager-abi.js';
+import { PriceFeedControllerAbi } from '../constants/abi/oracle-manager-abi.js';
+
+import type { GenericAddress } from '../../../../common/types/address.js';
+import type { GetReadContractReturnType } from '../../common/types/contract.js';
+import type { Client, GetContractReturnType, WalletClient } from 'viem';
+
+export function getAccountControllerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+): GetReadContractReturnType<typeof AccountControllerAbi> {
+  return getContract({
+    abi: AccountControllerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getBridgeRouterHubContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof BridgeRouterHubAbi>;
+export function getBridgeRouterHubContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof BridgeRouterHubAbi, Client>;
+export function getBridgeRouterHubContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof BridgeRouterHubAbi>
+  | GetContractReturnType<typeof BridgeRouterHubAbi, Client> {
+  return getContract({
+    abi: BridgeRouterHubAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getHubPoolContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof HubPoolAbi> {
+  return getContract({
+    abi: HubPoolAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function getLoanControllerContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof LoanControllerAbi>;
+
+export function getLoanControllerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof LoanControllerAbi, Client>;
+export function getLoanControllerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof LoanControllerAbi>
+  | GetContractReturnType<typeof LoanControllerAbi, Client> {
+  return getContract({
+    abi: LoanControllerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getPriceFeedControllerContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof PriceFeedControllerAbi> {
+  return getContract({
+    abi: PriceFeedControllerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function getNodeManagerContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof NodeManagerAbi> {
+  return getContract({
+    abi: NodeManagerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function getHubRewardsV1Contract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof HubRewardsV1Abi>;
+export function getHubRewardsV1Contract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof HubRewardsV1Abi, Client>;
+export function getHubRewardsV1Contract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof HubRewardsV1Abi>
+  | GetContractReturnType<typeof HubRewardsV1Abi, Client> {
+  return getContract({
+    abi: HubRewardsV1Abi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getHubRewardsV2Contract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof HubRewardsV2Abi>;
+export function getHubRewardsV2Contract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof HubRewardsV2Abi, Client>;
+export function getHubRewardsV2Contract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof HubRewardsV2Abi>
+  | GetContractReturnType<typeof HubRewardsV2Abi, Client> {
+  return getContract({
+    abi: HubRewardsV2Abi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}
+
+export function getHubContract(
+  provider: Client,
+  address: GenericAddress
+): GetReadContractReturnType<typeof HubAbi>;
+export function getHubContract(
+  provider: Client,
+  address: GenericAddress,
+  signer: WalletClient
+): GetContractReturnType<typeof HubAbi, Client>;
+export function getHubContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient
+):
+  | GetReadContractReturnType<typeof HubAbi>
+  | GetContractReturnType<typeof HubAbi, Client> {
+  return getContract({
+    abi: HubAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { wallet: signer, public: provider },
+  });
+}

package/src/chains/evm/hub/utils/events.ts

@@ -0,0 +1,160 @@
+import type { TSChainId } from '../../../../common/types/chain.js';
+import type {
+  AccountId,
+  LoanId,
+  LoanTypeId,
+} from '../../../../common/types/lending.js';
+import type {
+  AcceptInviteAddressEventParams,
+  InviteAddressEventParams,
+} from '../types/account.js';
+import type {
+  CreateUserLoanEventParams,
+  DeleteUserLoanEventParams,
+} from '../types/loan.js';
+
+export async function fetchCreateUserLoanEvents(
+  params: CreateUserLoanEventParams
+) {
+  const { loanController, accountId, loanTypeIds, eventParams } = params;
+  const logs = await loanController.getEvents.InitiateLoanAccount(
+    { accountId },
+    eventParams
+  );
+
+  return logs
+    .filter(
+      (log) =>
+        loanTypeIds === undefined ||
+        (log.args.loanTypeId &&
+          loanTypeIds.includes(log.args.loanTypeId as LoanTypeId))
+    )
+    .map((log) => ({
+      blockNumber: log.blockNumber,
+      loanId: log.args.loanId as LoanId,
+      accountId,
+      loanTypeId: log.args.loanTypeId as LoanTypeId,
+    }));
+}
+
+export async function fetchDeleteUserLoanEvents(
+  params: DeleteUserLoanEventParams
+) {
+  const { loanController, accountId, eventParams } = params;
+  const logs = await loanController.getEvents.DeleteUserLoanAccount(
+    { accountId },
+    eventParams
+  );
+  return logs.map((log) => ({
+    blockNumber: log.blockNumber,
+    loanId: log.args.loanId,
+    accountId,
+  }));
+}
+
+export async function fetchUserLoanIds(
+  params: CreateUserLoanEventParams
+): Promise<Map<LoanTypeId, Array<LoanId>>> {
+  const createdUserLoans = await fetchCreateUserLoanEvents(params);
+  const deletedUserLoans = await fetchDeleteUserLoanEvents(params);
+
+  // add created and remove deleted through counting
+  const loanIdsMap = new Map<
+    LoanId,
+    { loanTypeId: LoanTypeId; count: number }
+  >();
+  for (const userLoan of createdUserLoans) {
+    const loanId = userLoan.loanId;
+    const loanIdCount = loanIdsMap.get(loanId);
+    if (!loanIdCount)
+      loanIdsMap.set(loanId, { loanTypeId: userLoan.loanTypeId, count: 1 });
+    else loanIdCount.count++;
+  }
+  for (const userLoan of deletedUserLoans) {
+    const loanId = userLoan.loanId as LoanId;
+    const loanIdCount = loanIdsMap.get(loanId);
+    if (loanIdCount)
+      if (loanIdCount.count === 1) loanIdsMap.delete(loanId);
+      else loanIdCount.count--;
+  }
+
+  const loanTypeMap = new Map<LoanTypeId, Array<LoanId>>();
+
+  for (const [loanId, { loanTypeId }] of loanIdsMap.entries()) {
+    const loanTypeIds = loanTypeMap.get(loanTypeId);
+    if (!loanTypeIds) loanTypeMap.set(loanTypeId, [loanId]);
+    else loanTypeIds.push(loanId);
+  }
+
+  return loanTypeMap;
+}
+
+async function fetchReceivedInvitationEventByAddress(
+  params: InviteAddressEventParams
+) {
+  const { eventParams, accountController, address, tsChainId } = params;
+
+  const logs = await accountController.getEvents.InviteAddress(
+    { inviteeAddr: address, inviteeChainId: tsChainId },
+    eventParams
+  );
+  return logs.map((log) => ({
+    blockNumber: log.blockNumber,
+    accountId: log.args.accountId,
+    tsChainId: log.args.inviteeChainId,
+    id: `${log.args.accountId ?? ''}${log.args.inviteeChainId ?? ''}`,
+  }));
+}
+
+async function fetchAcceptedInvitationEventByAddress(
+  params: AcceptInviteAddressEventParams
+) {
+  const { eventParams, accountController, address, tsChainId } = params;
+
+  const logs = await accountController.getEvents.AcceptInviteAddress(
+    eventParams
+  );
+  return logs
+    .filter(
+      (log) =>
+        log.args.addr === address &&
+        (tsChainId ? log.args.chainId === tsChainId : true)
+    )
+    .map((log) => ({
+      blockNumber: log.blockNumber,
+      accountId: log.args.accountId,
+      tsChainId: log.args.chainId,
+      id: `${log.args.accountId ?? ''}${log.args.chainId ?? ''}`,
+    }));
+}
+
+export async function fetchInvitationByAddress(
+  params: InviteAddressEventParams
+) {
+  const receivedInvitations = await fetchReceivedInvitationEventByAddress(
+    params
+  );
+  const acceptedInvitations = await fetchAcceptedInvitationEventByAddress(
+    params
+  );
+
+  const allEvents = [...receivedInvitations, ...acceptedInvitations];
+  allEvents.sort((a, b) => Number(a.blockNumber) - Number(b.blockNumber));
+
+  const accountStatus = new Map();
+
+  for (const event of allEvents)
+    if (receivedInvitations.includes(event)) accountStatus.set(event.id, true);
+    else if (acceptedInvitations.includes(event))
+      accountStatus.set(event.id, false);
+
+  return {
+    address: params.address,
+    invitations: allEvents
+      .filter((log) => accountStatus.get(log.id))
+      .map((log) => ({
+        accountId: log.accountId as AccountId,
+        tsChainId: log.tsChainId as TSChainId,
+      })),
+  };
+}

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

@@ -0,0 +1,72 @@
+import {
+  calcBorrowBalance,
+  calcBorrowInterestIndex,
+  calcStableInterestRate,
+} from '../../../../common/utils/formulae.js';
+import { unixTime } from '../../../../common/utils/math-lib.js';
+
+import type { LoanControllerUserLoanBorrow } from '../types/loan.js';
+import type { PoolInfo } from '../types/pool.js';
+
+export function initLoanBorrowInterests(
+  isStable: boolean,
+  poolInfo: PoolInfo
+): LoanControllerUserLoanBorrow {
+  const lastInterestIndex = isStable
+    ? BigInt(1e18)
+    : poolInfo.variableBorrowData.interestIndex[0];
+  const stableInterestRate = isStable
+    ? poolInfo.stableBorrowData.interestRate[0]
+    : 0n;
+  const lastStableUpdateTimestamp = isStable ? BigInt(unixTime()) : 0n;
+  return {
+    amount: 0n,
+    balance: 0n,
+    lastInterestIndex,
+    stableInterestRate,
+    lastStableUpdateTimestamp,
+    rewardIndex: 0n,
+  };
+}
+
+export function updateLoanBorrowInterests(
+  borrow: LoanControllerUserLoanBorrow,
+  amount: bigint,
+  poolInfo: PoolInfo,
+  isStableInterestRateToUpdate: boolean
+): LoanControllerUserLoanBorrow {
+  if (borrow.lastStableUpdateTimestamp > 0) {
+    const oldInterestIndex = borrow.lastInterestIndex;
+    const oldStableInterestRate = borrow.stableInterestRate;
+    borrow.lastInterestIndex = calcBorrowInterestIndex(
+      [oldStableInterestRate, 18],
+      [oldInterestIndex, 18],
+      borrow.lastStableUpdateTimestamp
+    )[0];
+    borrow.lastStableUpdateTimestamp = BigInt(unixTime());
+
+    borrow.balance = calcBorrowBalance(
+      borrow.balance,
+      [borrow.lastInterestIndex, 18],
+      [oldInterestIndex, 18]
+    );
+
+    if (isStableInterestRateToUpdate) {
+      borrow.stableInterestRate = calcStableInterestRate(
+        borrow.balance,
+        amount,
+        [oldStableInterestRate, 18],
+        poolInfo.stableBorrowData.interestRate
+      )[0];
+    }
+  } else {
+    borrow.balance = calcBorrowBalance(
+      borrow.balance,
+      poolInfo.variableBorrowData.interestIndex,
+      [borrow.lastInterestIndex, 18]
+    );
+    borrow.lastInterestIndex = poolInfo.variableBorrowData.interestIndex[0];
+  }
+
+  return borrow;
+}