@folks-finance/xchain-sdk 0.0.1

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

@@ -0,0 +1,38 @@
+import { multicall } from "viem/actions";
+
+import { getHubChain } from "../utils/chain.js";
+import { getOracleManagerContract } from "../utils/contract.js";
+
+import type { NetworkType } from "../../../../common/types/chain.js";
+import type { OracleManagerAbi } from "../constants/abi/oracle-manager-abi.js";
+import type { OraclePrices } from "../types/oracle.js";
+import type { HubTokenData } from "../types/token.js";
+import type { Client, ContractFunctionParameters, ReadContractReturnType } from "viem";
+
+export async function getOraclePrices(
+  provider: Client,
+  network: NetworkType,
+  tokens: Array<HubTokenData>,
+): Promise<OraclePrices> {
+  const hubChain = getHubChain(network);
+  const oracleManager = getOracleManagerContract(provider, hubChain.oracleManagerAddress);
+
+  const processPriceFeeds: Array<ContractFunctionParameters> = tokens.map(({ poolId }) => ({
+    address: oracleManager.address,
+    abi: oracleManager.abi,
+    functionName: "processPriceFeed",
+    args: [poolId],
+  }));
+
+  const priceFeeds = (await multicall(provider, {
+    contracts: processPriceFeeds,
+    allowFailure: false,
+  })) as Array<ReadContractReturnType<typeof OracleManagerAbi, "processPriceFeed">>;
+
+  const oraclePrices: OraclePrices = {};
+  for (const [i, { price }] of priceFeeds.entries()) {
+    const token = tokens[i];
+    oraclePrices[token.folksTokenId] = [price, 18];
+  }
+  return oraclePrices;
+}

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

@@ -0,0 +1,171 @@
+import { multicall } from "viem/actions";
+
+import { calcBorrowInterestIndex, calcDepositInterestIndex } from "../../../../common/utils/formulae.js";
+import { compoundEveryHour, compoundEverySecond } from "../../../../common/utils/math-lib.js";
+import { getHubTokenData } from "../utils/chain.js";
+import { getHubPoolContract } from "../utils/contract.js";
+
+import type { NetworkType } from "../../../../common/types/chain.js";
+import type { FolksTokenId } 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,
+  folksTokenId: FolksTokenId,
+): Promise<PoolInfo> {
+  const {
+    poolAddress,
+    token: { decimals: tokenDecimals },
+  } = getHubTokenData(folksTokenId, network);
+  const hubPool = getHubPoolContract(provider, poolAddress);
+
+  // get pool data
+  const [
+    poolId,
+    lastUpdateTimestamp,
+    feeData,
+    depositData,
+    variableBorrowData,
+    stableBorrowData,
+    capsData,
+    configData,
+  ] = 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",
+      },
+    ],
+    allowFailure: false,
+  });
+
+  const { flashLoanFee, retentionRate } = 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,
+    rebalanceUpUtilisationRatio,
+    rebalanceUpDepositInterestRate,
+    rebalanceDownDelta,
+    totalAmount: stableBorrowTotalAmount,
+    interestRate: stableBorrowInterestRate,
+    averageInterestRate: stableBorrowAverageInterestRate,
+  } = stableBorrowData;
+  const { deposit: depositCap, borrow: borrowCap, stableBorrowPercentage: stableBorrowPercentageCap } = capsData;
+  const { deprecated, stableBorrowSupported, canMintFToken, flashLoanSupported } = configData;
+
+  // build pool info
+  return {
+    folksTokenId,
+    poolId,
+    tokenDecimals,
+    feeData: {
+      flashLoanFee: [BigInt(flashLoanFee), 6],
+      retentionRate: [BigInt(retentionRate), 6],
+    },
+    depositData: {
+      optimalUtilisationRatio: [BigInt(optimalUtilisationRatio), 4],
+      totalAmount: depositTotalAmount,
+      interestRate: [depositInterestRate, 18],
+      interestYield: compoundEveryHour([depositInterestRate, 18]),
+      interestIndex: calcDepositInterestIndex(
+        [depositInterestRate, 18],
+        [oldDepositInterestIndex, 18],
+        lastUpdateTimestamp,
+      ),
+    },
+    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,
+      ),
+    },
+    stableBorrowData: {
+      sr0: [BigInt(sr0), 6],
+      sr1: [BigInt(sr1), 6],
+      sr2: [BigInt(sr2), 6],
+      sr3: [BigInt(sr3), 6],
+      optimalStableToTotalDebtRatio: [BigInt(optimalStableToTotalDebtRatio), 4],
+      rebalanceUpUtilisationRatio: [BigInt(rebalanceUpUtilisationRatio), 4],
+      rebalanceUpDepositInterestRate: [BigInt(rebalanceUpDepositInterestRate), 4],
+      rebalanceDownDelta: [BigInt(rebalanceDownDelta), 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,
+      canMintFToken,
+      flashLoanSupported,
+    },
+  };
+}

package/src/chains/evm/hub/modules/index.ts

@@ -0,0 +1,5 @@
+export * as FolksHubAccount from "./folks-hub-account.js";
+export * as FolksHubLoan from "./folks-hub-loan.js";
+export * as FolksHubOracle from "./folks-hub-oracle.js";
+export * as FolksHubPool from "./folks-hub-pool.js";
+export * as FolksHubGmp from "./folks-hub-gmp.js";

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

@@ -0,0 +1,27 @@
+import type { GenericAddress } from "../../../../common/types/address.js";
+import type { FolksChainId } from "../../../../common/types/chain.js";
+import type { AccountId } from "../../../../common/types/lending.js";
+import type { GetEventParams, GetReadContractReturnType } from "../../common/types/contract.js";
+import type { AccountManagerAbi } from "../constants/abi/account-manager-abi.js";
+
+export type AccountInfo = {
+  registered: Map<FolksChainId, GenericAddress>;
+  invited: Map<FolksChainId, GenericAddress>;
+};
+
+export type AccountIdByAddress = Array<{
+  accountId: AccountId;
+  folksChainId: FolksChainId;
+}>;
+
+export type InviteAddressEventParams = GetEventParams & {
+  accountManager: GetReadContractReturnType<typeof AccountManagerAbi>;
+  address: GenericAddress;
+  folksChainId?: FolksChainId;
+};
+
+export type AcceptInviteAddressEventParams = GetEventParams & {
+  accountManager: GetReadContractReturnType<typeof AccountManagerAbi>;
+  address: GenericAddress;
+  folksChainId?: FolksChainId;
+};

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

@@ -0,0 +1,16 @@
+import type { HubTokenData } from "./token.js";
+import type { GenericAddress } from "../../../../common/types/address.js";
+import type { IFolksChain } from "../../../../common/types/chain.js";
+import type { AdapterType } from "../../../../common/types/message.js";
+import type { FolksTokenId } from "../../../../common/types/token.js";
+
+export type HubChain = {
+  hubAddress: GenericAddress;
+  bridgeRouterAddress: GenericAddress;
+  adapters: Record<AdapterType, GenericAddress>;
+  oracleManagerAddress: GenericAddress;
+  spokeManagerAddress: GenericAddress;
+  accountManagerAddress: GenericAddress;
+  loanManagerAddress: GenericAddress;
+  tokens: Partial<Record<FolksTokenId, HubTokenData>>;
+} & IFolksChain;

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

@@ -0,0 +1,147 @@
+import type { PoolInfo } from "./pool.js";
+import type { AccountId, LoanId } from "../../../../common/types/lending.js";
+import type { LoanTypeId } from "../../../../common/types/module.js";
+import type { FolksTokenId } from "../../../../common/types/token.js";
+import type { GetEventParams, GetReadContractReturnType } from "../../common/types/contract.js";
+import type { LoanManagerAbi } from "../constants/abi/loan-manager-abi.js";
+import type { Dnum } from "dnum";
+import type { ReadContractReturnType } from "viem";
+
+export type LoanPoolInfo = {
+  folksTokenId: FolksTokenId;
+  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<FolksTokenId, LoanPoolInfo>>;
+};
+
+export type UserLoanInfoCollateral = {
+  folksTokenId: FolksTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  tokenPrice: Dnum;
+  collateralFactor: Dnum;
+  fTokenBalance: bigint;
+  tokenBalance: bigint;
+  balanceValue: Dnum;
+  effectiveBalanceValue: Dnum;
+  interestRate: Dnum;
+  interestYield: Dnum;
+};
+
+export type UserLoanInfoBorrow = {
+  folksTokenId: FolksTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  tokenPrice: Dnum;
+  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<FolksTokenId, UserLoanInfoCollateral>>;
+  borrows: Partial<Record<FolksTokenId, UserLoanInfoBorrow>>;
+  netRate: Dnum;
+  netYield: Dnum;
+  totalCollateralBalanceValue: Dnum;
+  totalBorrowedAmountValue: Dnum;
+  totalBorrowBalanceValue: Dnum;
+  totalEffectiveCollateralBalanceValue: Dnum;
+  totalEffectiveBorrowBalanceValue: Dnum;
+  loanToValueRatio: Dnum;
+  borrowUtilisationRatio: Dnum;
+  liquidationMargin: Dnum;
+};
+
+export type CreateUserLoanEventParams = GetEventParams & {
+  loanManager: GetReadContractReturnType<typeof LoanManagerAbi>;
+  accountId: AccountId;
+  loanTypeIds?: Array<LoanTypeId>;
+};
+
+export type DeleteUserLoanEventParams = GetEventParams & {
+  loanManager: GetReadContractReturnType<typeof LoanManagerAbi>;
+  accountId: AccountId;
+};
+
+export type LoanManagerUserLoan = ReadContractReturnType<typeof LoanManagerAbi, "getUserLoan">;
+
+export type LoanManagerUserLoanBorrow = LoanManagerUserLoan[5][0];
+
+export enum LoanChangeType {
+  AddCollateral,
+  ReduceCollateral,
+  Borrow,
+  Repay,
+  SwitchBorrowType,
+}
+
+type LoanBaseChange = {
+  type: LoanChangeType;
+  poolInfo: PoolInfo;
+};
+
+type LoanAddCollateralChange = LoanBaseChange & {
+  type: LoanChangeType.AddCollateral;
+  fTokenAmount: bigint;
+};
+
+type LoanReduceCollateralChange = LoanBaseChange & {
+  type: LoanChangeType.ReduceCollateral;
+  fTokenAmount: 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,6 @@
+import type { FolksTokenId } from "../../../../common/types/token.js";
+import type { Dnum } from "dnum";
+
+export type OraclePrice = Dnum;
+
+export type OraclePrices = Partial<Record<FolksTokenId, OraclePrice>>;

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

@@ -0,0 +1,66 @@
+import type { FolksTokenId } from "../../../../common/types/token.js";
+import type { Dnum } from "dnum";
+
+type FeeData = {
+  flashLoanFee: Dnum;
+  retentionRate: Dnum;
+};
+
+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;
+  rebalanceUpUtilisationRatio: Dnum;
+  rebalanceUpDepositInterestRate: Dnum;
+  rebalanceDownDelta: 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;
+  canMintFToken: boolean;
+  flashLoanSupported: boolean;
+};
+
+export type PoolInfo = {
+  folksTokenId: FolksTokenId;
+  poolId: number;
+  tokenDecimals: number;
+  feeData: FeeData;
+  depositData: DepositData;
+  variableBorrowData: VariableBorrowData;
+  stableBorrowData: StableBorrowData;
+  capsData: CapsData;
+  configData: ConfigData;
+};

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/module.js";
+import type { FolksHubTokenType, ITokenData } from "../../../../common/types/token.js";
+
+export type HubTokenData = {
+  poolId: number;
+  poolAddress: GenericAddress;
+  token: FolksHubTokenType;
+  supportedLoanTypes: Set<LoanTypeId>;
+} & ITokenData;

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

@@ -0,0 +1,41 @@
+import { HUB_CHAIN } from "../constants/chain.js";
+
+import type { FolksChainId, NetworkType } from "../../../../common/types/chain.js";
+import type { AdapterType } from "../../../../common/types/message.js";
+import type { LoanTypeId } from "../../../../common/types/module.js";
+import type { FolksTokenId } from "../../../../common/types/token.js";
+import type { HubChain } from "../types/chain.js";
+import type { HubTokenData } from "../types/token.js";
+
+export function isHubChain(folksChainId: FolksChainId, network: NetworkType): boolean {
+  return HUB_CHAIN[network].folksChainId === folksChainId;
+}
+
+export function getHubChain(network: NetworkType): HubChain {
+  return HUB_CHAIN[network];
+}
+
+export function getHubTokensData(network: NetworkType): Partial<Record<FolksTokenId, HubTokenData>> {
+  return HUB_CHAIN[network].tokens;
+}
+
+export function getHubTokenData(folksTokenId: FolksTokenId, network: NetworkType): HubTokenData {
+  const token = HUB_CHAIN[network].tokens[folksTokenId];
+  if (!token) throw new Error(`Hub token not found for folksTokenId: ${folksTokenId}`);
+  return token;
+}
+
+export function isLoanTypeSupported(loanType: LoanTypeId, folksTokenId: FolksTokenId, network: NetworkType): boolean {
+  const token = getHubTokenData(folksTokenId, network);
+  return token.supportedLoanTypes.has(loanType);
+}
+
+export function assertLoanTypeSupported(loanType: LoanTypeId, folksTokenId: FolksTokenId, network: NetworkType): void {
+  if (!isLoanTypeSupported(loanType, folksTokenId, network))
+    throw new Error(`Loan type ${loanType} is not supported for folksTokenId: ${folksTokenId}`);
+}
+
+export function getHubChainAdapterAddress(network: NetworkType, adapterType: AdapterType) {
+  const hubChain = getHubChain(network);
+  return hubChain.adapters[adapterType];
+}

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

@@ -0,0 +1,98 @@
+import { getContract } from "viem";
+
+import { ChainType } from "../../../../common/types/chain.js";
+import { convertFromGenericAddress } from "../../../../common/utils/address.js";
+import { AccountManagerAbi } 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 { LoanManagerAbi } from "../constants/abi/loan-manager-abi.js";
+import { OracleManagerAbi } 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 getAccountManagerContract(
+  provider: Client,
+  address: GenericAddress,
+  signer?: WalletClient,
+): GetReadContractReturnType<typeof AccountManagerAbi> {
+  return getContract({
+    abi: AccountManagerAbi,
+    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 getLoanManagerContract(
+  provider: Client,
+  address: GenericAddress,
+): GetReadContractReturnType<typeof LoanManagerAbi> {
+  return getContract({
+    abi: LoanManagerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { public: provider },
+  });
+}
+
+export function getOracleManagerContract(
+  provider: Client,
+  address: GenericAddress,
+): GetReadContractReturnType<typeof OracleManagerAbi> {
+  return getContract({
+    abi: OracleManagerAbi,
+    address: convertFromGenericAddress<ChainType.EVM>(address, ChainType.EVM),
+    client: { 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 },
+  });
+}