@huma-finance/shared 0.0.48-beta.202 → 0.0.48-beta.279

package/dist/v2/metadata/mumbai.d.ts

@@ -0,0 +1,2 @@
+import { PoolsInfoV2 } from '../utils';
+export declare const MUMBAI_METADATA: PoolsInfoV2;

package/dist/v2/metadata/mumbai.js

@@ -0,0 +1,52 @@
+import { ChainEnum } from '../../utils/chain';
+import { POOL_NAME, POOL_TYPE } from '../../utils/pool';
+import { FirstLossCoverIndex } from '../types';
+export const MUMBAI_METADATA = {
+    JiaV2: {
+        chainId: ChainEnum.Mumbai,
+        poolVersion: 'v2',
+        poolName: POOL_NAME.JiaV2,
+        poolType: POOL_TYPE.CreditLine,
+        pool: '0x670bd29Db78Cb1e80C339C6061D969a97a1412CF',
+        poolCredit: '0xD8127E51Ba777F1153B0caF0e7f685A717aA1dCc',
+        poolCreditManager: '0x936FBB4b24b76AB9F80278C50Ff6410A2664B3e8',
+        poolConfig: '0x0A395b280fcB4a95e7c568d2Fc8329Cb3530B80D',
+        poolSafe: '0x72977d89449BF57964D33968FEdaDd038A705e00',
+        seniorTrancheVault: '0x3f9e60A1B9a6B0B23314D5861DcA88405E662128',
+        juniorTrancheVault: '0xfc02995a9f6c1bb1383Cb8B9F69D3ADd0f736524',
+        epochManager: '0xE53A68Fb7a8A4e115e044a66224750acf54F638f',
+        firstLossCovers: {
+            [FirstLossCoverIndex.borrower]: '0x048B50b463Af8ccCA0BE2b08149720739aD466eB',
+            [FirstLossCoverIndex.affiliate]: '0x83EeFf2D39C1387C18E1B888A40B3Bf4a0E1C34C',
+        },
+        seniorAPY: '10-20%',
+        juniorAPY: '10-20%',
+        title: 'Jia V2 Testing Pool',
+        desc: 'Jia brings real-world asset returns to crypto investors while tackling the multi-trillion-dollar credit gap in emerging markets. By providing blockchain-based financing to small businesses and rewarding borrowers who repay with ownership, Jia enables them to create wealth and prosperity for themselves and their communities.',
+        supplyLink: 'https://app.huma.finance',
+    },
+    ArfCreditPoolV2: {
+        chainId: ChainEnum.Mumbai,
+        poolVersion: 'v2',
+        poolName: POOL_NAME.ArfCreditPoolV2,
+        poolType: POOL_TYPE.ReceivableBackedCreditLine,
+        pool: '0xc1aad5d015bC5906f92d46910eBb9919fcc7BFB5',
+        poolConfig: '0xB1BDc89E4C2dC795d7d44D697E5d62E4fB1E5Ed7',
+        poolCredit: '0x880eCAc83ae113af5f4C1b90705467d6A18fc8AD',
+        poolCreditManager: '0xa85d4C33ef3728fC38E9281FCd08b0b88CEF1912',
+        poolSafe: '0x53a3a2495fD279964398998eb8aaaA21B1289770',
+        seniorTrancheVault: '0x57B0936B1CEe19642FBd659C8e417E084ffab8fF',
+        juniorTrancheVault: '0x7d566A84AE84974d4812fEA760958E40ff91f7Da',
+        epochManager: '0xf9eEB9c32d7822fF9111A75b330A6948B7A6818a',
+        firstLossCovers: {
+            [FirstLossCoverIndex.borrower]: '0x81aA17cC36BA98d61542F7D17Ea8a3a621Cc5666',
+            [FirstLossCoverIndex.affiliate]: '0xa36c775a88E9A7c55B526EeefDcAFF7Bcca5aD1E',
+        },
+        seniorAPY: '10-20%',
+        juniorAPY: '10-20%',
+        title: 'Arf V2 Testing Pool',
+        desc: 'Arf provides an innovative on-chain liquidity solution that simplifies cross-border payments by facilitating immediate USDC-based settlements and tokenizing payment orders, enhancing transparency in the process.',
+        supplyLink: 'https://app.huma.finance',
+    },
+};
+//# sourceMappingURL=mumbai.js.map

package/dist/v2/metadata/mumbai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mumbai.js","sourceRoot":"","sources":["../../../src/v2/metadata/mumbai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAG9C,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,KAAK,EAAE;QACL,OAAO,EAAE,SAAS,CAAC,MAAM;QACzB,WAAW,EAAE,IAAI;QACjB,QAAQ,EAAE,SAAS,CAAC,KAAK;QACzB,QAAQ,EAAE,SAAS,CAAC,UAAU;QAC9B,IAAI,EAAE,4CAA4C;QAClD,UAAU,EAAE,4CAA4C;QACxD,iBAAiB,EAAE,4CAA4C;QAC/D,UAAU,EAAE,4CAA4C;QACxD,QAAQ,EAAE,4CAA4C;QACtD,kBAAkB,EAAE,4CAA4C;QAChE,kBAAkB,EAAE,4CAA4C;QAChE,YAAY,EAAE,4CAA4C;QAC1D,eAAe,EAAE;YACf,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAC5B,4CAA4C;YAC9C,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAC7B,4CAA4C;SAC/C;QACD,SAAS,EAAE,QAAQ;QACnB,SAAS,EAAE,QAAQ;QACnB,KAAK,EAAE,qBAAqB;QAC5B,IAAI,EAAE,uUAAuU;QAC7U,UAAU,EAAE,0BAA0B;KACvC;IACD,eAAe,EAAE;QACf,OAAO,EAAE,SAAS,CAAC,MAAM;QACzB,WAAW,EAAE,IAAI;QACjB,QAAQ,EAAE,SAAS,CAAC,eAAe;QACnC,QAAQ,EAAE,SAAS,CAAC,0BAA0B;QAC9C,IAAI,EAAE,4CAA4C;QAClD,UAAU,EAAE,4CAA4C;QACxD,UAAU,EAAE,4CAA4C;QACxD,iBAAiB,EAAE,4CAA4C;QAC/D,QAAQ,EAAE,4CAA4C;QACtD,kBAAkB,EAAE,4CAA4C;QAChE,kBAAkB,EAAE,4CAA4C;QAChE,YAAY,EAAE,4CAA4C;QAC1D,eAAe,EAAE;YACf,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAC5B,4CAA4C;YAC9C,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAC7B,4CAA4C;SAC/C;QACD,SAAS,EAAE,QAAQ;QACnB,SAAS,EAAE,QAAQ;QACnB,KAAK,EAAE,qBAAqB;QAC5B,IAAI,EAAE,qNAAqN;QAC3N,UAAU,EAAE,0BAA0B;KACvC;CACF,CAAA"}

package/dist/v2/types/index.d.ts

@@ -0,0 +1,4 @@
+export declare enum FirstLossCoverIndex {
+    borrower = 0,
+    affiliate = 2
+}

package/dist/v2/types/index.js

@@ -0,0 +1,6 @@
+export var FirstLossCoverIndex;
+(function (FirstLossCoverIndex) {
+    FirstLossCoverIndex[FirstLossCoverIndex["borrower"] = 0] = "borrower";
+    FirstLossCoverIndex[FirstLossCoverIndex["affiliate"] = 2] = "affiliate";
+})(FirstLossCoverIndex || (FirstLossCoverIndex = {}));
+//# sourceMappingURL=index.js.map

package/dist/v2/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v2/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,qEAAY,CAAA;IACZ,uEAAa,CAAA;AACf,CAAC,EAHW,mBAAmB,KAAnB,mBAAmB,QAG9B"}

package/dist/v2/utils/const.d.ts

@@ -0,0 +1,10 @@
+import { BigNumber } from 'ethers';
+export declare const BP_FACTOR: BigNumber;
+export declare enum CreditStateV2 {
+    Deleted = 0,
+    Paused = 1,
+    Approved = 2,
+    GoodStanding = 3,
+    Delayed = 4,
+    Defaulted = 5
+}

package/dist/v2/utils/const.js

@@ -0,0 +1,12 @@
+import { BigNumber } from 'ethers';
+export const BP_FACTOR = BigNumber.from(10000);
+export var CreditStateV2;
+(function (CreditStateV2) {
+    CreditStateV2[CreditStateV2["Deleted"] = 0] = "Deleted";
+    CreditStateV2[CreditStateV2["Paused"] = 1] = "Paused";
+    CreditStateV2[CreditStateV2["Approved"] = 2] = "Approved";
+    CreditStateV2[CreditStateV2["GoodStanding"] = 3] = "GoodStanding";
+    CreditStateV2[CreditStateV2["Delayed"] = 4] = "Delayed";
+    CreditStateV2[CreditStateV2["Defaulted"] = 5] = "Defaulted";
+})(CreditStateV2 || (CreditStateV2 = {}));
+//# sourceMappingURL=const.js.map

package/dist/v2/utils/const.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.js","sourceRoot":"","sources":["../../../src/v2/utils/const.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAElC,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AAE9C,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,uDAAO,CAAA;IACP,qDAAM,CAAA;IACN,yDAAQ,CAAA;IACR,iEAAY,CAAA;IACZ,uDAAO,CAAA;IACP,2DAAS,CAAA;AACX,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB"}

package/dist/v2/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './const';
+export * from './pool';
+export * from './poolContract';

package/dist/v2/utils/index.js

@@ -0,0 +1,4 @@
+export * from './const';
+export * from './pool';
+export * from './poolContract';
+//# sourceMappingURL=index.js.map

package/dist/v2/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v2/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,gBAAgB,CAAA"}

package/dist/v2/utils/pool.d.ts

@@ -0,0 +1,87 @@
+import { BigNumber } from 'ethers';
+import { ChainEnum, LenderApprovalProvider, POOL_NAME, POOL_TYPE, PoolVersion } from '../../utils';
+import { FirstLossCoverIndex } from '../types';
+export type TrancheType = 'senior' | 'junior';
+export type KYCCopy = {
+    title: string;
+    description: string;
+    buttonText?: string;
+};
+export type PoolInfoV2 = {
+    chainId: ChainEnum;
+    poolVersion: PoolVersion;
+    poolName: POOL_NAME;
+    poolType: POOL_TYPE;
+    pool: string;
+    poolConfig: string;
+    poolCredit: string;
+    poolCreditManager: string;
+    poolSafe: string;
+    seniorTrancheVault: string;
+    juniorTrancheVault: string;
+    epochManager: string;
+    firstLossCovers: {
+        [FirstLossCoverIndex.borrower]: string;
+        [FirstLossCoverIndex.affiliate]: string;
+    };
+    poolAbi?: unknown;
+    poolCreditAbi?: unknown;
+    poolCreditManagerAbi?: unknown;
+    poolSafeAbi?: unknown;
+    poolConfigAbi?: unknown;
+    trancheVaultAbi?: unknown;
+    firstLossCoverAbi?: unknown;
+    epochManagerAbi?: unknown;
+    calendarAbi?: unknown;
+    seniorAPY: string;
+    juniorAPY: string;
+    title: string;
+    desc: string;
+    lenderApprovalProvider?: LenderApprovalProvider;
+    industry?: 'Supply Chain Financing' | 'Remittance Financing' | 'Green Financing' | 'Invoice Factoring';
+    KYC?: {
+        provider: 'Securitize';
+        signInRequired: KYCCopy;
+        verifyIdentity: KYCCopy;
+        emailSignatureLink: KYCCopy;
+        resendSignatureLink: KYCCopy;
+        docUnderReview: KYCCopy;
+    };
+    supplyLink?: string;
+    poolUnderlyingToken?: {
+        address: string;
+        symbol: string;
+        decimals: number;
+        icon: string;
+    };
+};
+export type PoolsInfoV2 = {
+    [poolName in POOL_NAME]?: PoolInfoV2;
+};
+export type ChainPoolsInfoV2 = {
+    [chainId in ChainEnum]: PoolsInfoV2;
+};
+export declare const CHAIN_POOLS_INFO_V2: ChainPoolsInfoV2;
+export declare const getChainPoolNamesV2: (chainId: number | undefined) => POOL_NAME[] | undefined;
+export declare const isV2Pool: (chainId: number, pool: string) => boolean;
+export type UnderlyingTokenInfo = {
+    address: string;
+    symbol: string;
+    decimals: number;
+};
+export type PoolSafeStatsV2 = {
+    allowance: BigNumber;
+};
+export type FirstLossCoverInfoV2 = {
+    totalAssets: BigNumber;
+};
+export type TrancheVaultInfoV2 = {
+    totalAssets: BigNumber;
+};
+export type TrancheVaultStatsV2 = {
+    lenderApproved: boolean;
+    lenderPosition: BigNumber;
+};
+export type UnderlyingTokenStatsV2 = {
+    balance: BigNumber;
+};

package/dist/v2/utils/pool.js

@@ -0,0 +1,53 @@
+import { ChainEnum, isChainEnum, } from '../../utils';
+import { HUMA_TESTNET_METADATA } from '../metadata/humaTestnet';
+import { LOCALHOST_METADATA } from '../metadata/localhost';
+import { MUMBAI_METADATA } from '../metadata/mumbai';
+import { FirstLossCoverIndex } from '../types';
+import POOL_CREDIT_ABI from '../abis/Credit.json';
+import POOL_CREDIT_MANAGER_ABI from '../abis/CreditManager.json';
+import EPOCH_MANAGER_ABI from '../abis/EpochManager.json';
+import FIRST_LOSS_COVER_ABI from '../abis/FirstLossCover.json';
+import POOL_ABI from '../abis/Pool.json';
+import POOL_CONFIG_ABI from '../abis/PoolConfig.json';
+import POOL_SAFE_ABI from '../abis/PoolSafe.json';
+import TRANCHE_VAULT_ABI from '../abis/TrancheVault.json';
+import CALENDAR_ABI from '../abis/Calendar.json';
+const getMetadataWithAbis = (metadata) => {
+    Object.keys(metadata).forEach((poolName) => {
+        const pool = metadata[poolName];
+        if (pool) {
+            pool.poolAbi = POOL_ABI;
+            pool.poolCreditAbi = POOL_CREDIT_ABI;
+            pool.poolCreditManagerAbi = POOL_CREDIT_MANAGER_ABI;
+            pool.poolSafeAbi = POOL_SAFE_ABI;
+            pool.poolConfigAbi = POOL_CONFIG_ABI;
+            pool.trancheVaultAbi = TRANCHE_VAULT_ABI;
+            pool.firstLossCoverAbi = FIRST_LOSS_COVER_ABI;
+            pool.epochManagerAbi = EPOCH_MANAGER_ABI;
+            pool.calendarAbi = CALENDAR_ABI;
+        }
+    });
+    return metadata;
+};
+export const CHAIN_POOLS_INFO_V2 = {
+    [ChainEnum.Mumbai]: getMetadataWithAbis(MUMBAI_METADATA),
+    [ChainEnum.HumaTestnet]: getMetadataWithAbis(HUMA_TESTNET_METADATA),
+    [ChainEnum.Localhost]: getMetadataWithAbis(LOCALHOST_METADATA),
+};
+export const getChainPoolNamesV2 = (chainId) => {
+    if (!chainId) {
+        return undefined;
+    }
+    if (!isChainEnum(chainId) || !CHAIN_POOLS_INFO_V2[chainId]) {
+        return [];
+    }
+    return Object.keys(CHAIN_POOLS_INFO_V2[chainId]);
+};
+export const isV2Pool = (chainId, pool) => {
+    const chainPoolsInfo = CHAIN_POOLS_INFO_V2[chainId];
+    if (!chainPoolsInfo) {
+        return false;
+    }
+    return Object.values(chainPoolsInfo).some((poolInfo) => poolInfo.pool.toLowerCase() === pool.toLowerCase());
+};
+//# sourceMappingURL=pool.js.map

package/dist/v2/utils/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../../src/v2/utils/pool.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,WAAW,GAKZ,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,eAAe,MAAM,qBAAqB,CAAA;AACjD,OAAO,uBAAuB,MAAM,4BAA4B,CAAA;AAChE,OAAO,iBAAiB,MAAM,2BAA2B,CAAA;AACzD,OAAO,oBAAoB,MAAM,6BAA6B,CAAA;AAC9D,OAAO,QAAQ,MAAM,mBAAmB,CAAA;AACxC,OAAO,eAAe,MAAM,yBAAyB,CAAA;AACrD,OAAO,aAAa,MAAM,uBAAuB,CAAA;AACjD,OAAO,iBAAiB,MAAM,2BAA2B,CAAA;AACzD,OAAO,YAAY,MAAM,uBAAuB,CAAA;AAuEhD,MAAM,mBAAmB,GAAG,CAAC,QAAqB,EAAE,EAAE;IACpD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;QACzC,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAqB,CAAC,CAAA;QAC5C,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAA;YACvB,IAAI,CAAC,aAAa,GAAG,eAAe,CAAA;YACpC,IAAI,CAAC,oBAAoB,GAAG,uBAAuB,CAAA;YACnD,IAAI,CAAC,WAAW,GAAG,aAAa,CAAA;YAChC,IAAI,CAAC,aAAa,GAAG,eAAe,CAAA;YACpC,IAAI,CAAC,eAAe,GAAG,iBAAiB,CAAA;YACxC,IAAI,CAAC,iBAAiB,GAAG,oBAAoB,CAAA;YAC7C,IAAI,CAAC,eAAe,GAAG,iBAAiB,CAAA;YACxC,IAAI,CAAC,WAAW,GAAG,YAAY,CAAA;SAChC;IACH,CAAC,CAAC,CAAA;IACF,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,eAAe,CAAC;IACxD,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC,qBAAqB,CAAC;IACnE,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC,kBAAkB,CAAC;CAC3C,CAAA;AAErB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,OAA2B,EACF,EAAE;IAC3B,IAAI,CAAC,OAAO,EAAE;QACZ,OAAO,SAAS,CAAA;KACjB;IAED,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAAE;QAC1D,OAAO,EAAE,CAAA;KACV;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAgB,CAAA;AACjE,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,OAAe,EAAE,IAAY,EAAW,EAAE;IACjE,MAAM,cAAc,GAAG,mBAAmB,CAAC,OAAoB,CAAC,CAAA;IAChE,IAAI,CAAC,cAAc,EAAE;QACnB,OAAO,KAAK,CAAA;KACb;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,CACvC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,WAAW,EAAE,CACjE,CAAA;AACH,CAAC,CAAA"}

package/dist/v2/utils/poolContract.d.ts

@@ -0,0 +1,44 @@
+import { JsonRpcProvider, Web3Provider } from '@ethersproject/providers';
+import { BigNumber, ethers } from 'ethers';
+import { PoolInfoV2, TrancheType, UnderlyingTokenInfo } from '.';
+import { POOL_NAME } from '../../utils';
+import { Credit, EpochManager, FirstLossCover, Pool, PoolConfig, TrancheVault } from '../abis/types';
+import { CreditRecordStructOutput, DueDetailStructOutput } from '../abis/types/Credit';
+import { CreditConfigStructOutput, CreditManager } from '../abis/types/CreditManager';
+import { FirstLossCoverIndex } from '../types';
+export declare const getPoolInfoV2: (poolName: POOL_NAME, chainId: number | undefined) => PoolInfoV2 | null;
+export declare const getPoolContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<Pool | null>;
+export declare const getPoolConfigContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<PoolConfig | null>;
+export declare const getPoolUnderlyingTokenContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<ethers.Contract | null>;
+export declare const getPoolUnderlyingTokenBalanceV2: (poolName: POOL_NAME, address: string, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<BigNumber | null>;
+export declare const getPoolCreditContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<Credit | null>;
+export declare const getPoolCreditManagerContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<CreditManager | null>;
+export declare const getTrancheVaultContractV2: (poolName: POOL_NAME, trancheType: TrancheType, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<TrancheVault | null>;
+export declare const getEpochManagerContractV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<EpochManager | null>;
+export declare const getFirstLossCoverContractV2: (poolName: POOL_NAME, firstLossCoverType: FirstLossCoverIndex, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<FirstLossCover | null>;
+export declare const getPoolUnderlyingTokenInfoV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<UnderlyingTokenInfo | undefined>;
+export declare const getFirstLossCoverAssetsV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<BigNumber | undefined>;
+export declare const getTrancheVaultAssetsV2: (poolName: POOL_NAME, trancheType: TrancheType, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<BigNumber | undefined>;
+type LenderPosition = {
+    shares: BigNumber;
+    assets: BigNumber;
+};
+export declare const getLenderPositionV2: (poolName: POOL_NAME, trancheType: TrancheType, account: string | undefined, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<LenderPosition | undefined>;
+export declare const getTrancheAssetsToSharesV2: (poolName: POOL_NAME, trancheType: TrancheType, provider: JsonRpcProvider | Web3Provider | undefined, assets: BigNumber | undefined) => Promise<BigNumber | undefined>;
+export declare const getTrancheSharesToAssetsV2: (poolName: POOL_NAME, trancheType: TrancheType, provider: JsonRpcProvider | Web3Provider | undefined, shares: BigNumber | undefined) => Promise<BigNumber | undefined>;
+export declare const getCreditHashV2: (poolName: POOL_NAME, chainId: number | undefined, account: string | undefined) => string | undefined;
+export declare const getCreditRecordV2: (poolName: POOL_NAME, chainId: number | undefined, account: string | undefined, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<CreditRecordStructOutput | undefined>;
+export declare const getDueDetailV2: (poolName: POOL_NAME, chainId: number | undefined, account: string | undefined, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<DueDetailStructOutput | undefined>;
+export declare const getCreditConfigV2: (poolName: POOL_NAME, chainId: number | undefined, account: string | undefined, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<CreditConfigStructOutput | undefined>;
+export declare const getCurrentEpochInfoV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<EpochManager.CurrentEpochStructOutput | undefined>;
+export declare const getPoolFeeStructureV2: (poolName: POOL_NAME, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<{
+    yield: number;
+    minPrincipalRate: number;
+    lateFee: number;
+} | undefined>;
+export declare const getApyV2: (poolName: POOL_NAME, chainId: number | undefined, provider: JsonRpcProvider | Web3Provider | undefined) => Promise<{
+    seniorTrancheApy: number;
+    juniorTrancheApy: number;
+    firstLossCoverApy: number;
+} | undefined>;
+export {};

package/dist/v2/utils/poolContract.js

@@ -0,0 +1,322 @@
+import { BigNumber, ethers } from 'ethers';
+import { BP_FACTOR, CHAIN_POOLS_INFO_V2, } from '.';
+import { getChainIdFromSignerOrProvider, getContract, getERC20Contract, isChainEnum, } from '../../utils';
+import CREDIT_ABI from '../abis/Credit.json';
+import CREDIT_MANAGER_ABI from '../abis/CreditManager.json';
+import HUMA_CONFIG_ABI from '../abis/HumaConfig.json';
+export const getPoolInfoV2 = (poolName, chainId) => {
+    var _a;
+    if (isChainEnum(chainId)) {
+        return (_a = CHAIN_POOLS_INFO_V2[chainId]) === null || _a === void 0 ? void 0 : _a[poolName];
+    }
+    return null;
+};
+export const getPoolContractV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.pool, poolInfo.poolAbi, provider);
+};
+export const getPoolConfigContractV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.poolConfig, poolInfo.poolConfigAbi, provider);
+};
+export const getPoolUnderlyingTokenContractV2 = async (poolName, provider) => {
+    const poolConfigContract = await getPoolConfigContractV2(poolName, provider);
+    if (!poolConfigContract) {
+        return null;
+    }
+    const underlyingToken = await poolConfigContract.underlyingToken();
+    return getERC20Contract(underlyingToken, provider);
+};
+export const getPoolUnderlyingTokenBalanceV2 = async (poolName, address, provider) => {
+    const poolUnderlyingTokenContract = await getPoolUnderlyingTokenContractV2(poolName, provider);
+    if (!poolUnderlyingTokenContract) {
+        return null;
+    }
+    return poolUnderlyingTokenContract.balanceOf(address);
+};
+export const getPoolCreditContractV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.poolCredit, CREDIT_ABI, provider);
+};
+export const getPoolCreditManagerContractV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.poolCreditManager, CREDIT_MANAGER_ABI, provider);
+};
+export const getTrancheVaultContractV2 = async (poolName, trancheType, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    const trancheVault = `${trancheType}TrancheVault`;
+    return getContract(poolInfo[trancheVault], poolInfo.trancheVaultAbi, provider);
+};
+export const getEpochManagerContractV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.epochManager, poolInfo.epochManagerAbi, provider);
+};
+export const getFirstLossCoverContractV2 = async (poolName, firstLossCoverType, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return null;
+    }
+    return getContract(poolInfo.firstLossCovers[firstLossCoverType], poolInfo.firstLossCoverAbi, provider);
+};
+export const getPoolUnderlyingTokenInfoV2 = async (poolName, provider) => {
+    const underlyingTokenContract = await getPoolUnderlyingTokenContractV2(poolName, provider);
+    if (!underlyingTokenContract) {
+        return undefined;
+    }
+    const [symbol, decimals] = await Promise.all([
+        underlyingTokenContract.symbol(),
+        underlyingTokenContract.decimals(),
+    ]);
+    return {
+        address: underlyingTokenContract.address,
+        symbol,
+        decimals,
+    };
+};
+export const getFirstLossCoverAssetsV2 = async (poolName, provider) => {
+    const chainId = await getChainIdFromSignerOrProvider(provider);
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    const poolConfigContract = await getPoolConfigContractV2(poolName, provider);
+    if (!poolConfigContract) {
+        return undefined;
+    }
+    const firstLossCovers = await poolConfigContract.getFirstLossCovers();
+    const firstLossCoverContracts = firstLossCovers
+        .filter((item) => !!item)
+        .map((item) => getContract(item, poolInfo.firstLossCoverAbi, provider))
+        .flatMap((item) => (item ? [item] : []));
+    const firstLossCoverAssets = await Promise.all(firstLossCoverContracts.map((contract) => contract.totalAssets()));
+    let totalAssets = BigNumber.from(0);
+    firstLossCoverAssets.forEach((assets) => {
+        totalAssets = totalAssets.add(assets);
+    });
+    return totalAssets;
+};
+export const getTrancheVaultAssetsV2 = async (poolName, trancheType, provider) => {
+    const trancheVaultContract = await getTrancheVaultContractV2(poolName, trancheType, provider);
+    if (!trancheVaultContract) {
+        return undefined;
+    }
+    return trancheVaultContract.totalAssets();
+};
+export const getLenderPositionV2 = async (poolName, trancheType, account, provider) => {
+    if (!account) {
+        return undefined;
+    }
+    const vaultContract = await getTrancheVaultContractV2(poolName, trancheType, provider);
+    if (!vaultContract) {
+        return undefined;
+    }
+    const [shares, assets] = await Promise.all([
+        vaultContract.balanceOf(account),
+        vaultContract.totalAssetsOf(account),
+    ]);
+    return {
+        shares,
+        assets,
+    };
+};
+export const getTrancheAssetsToSharesV2 = async (poolName, trancheType, provider, assets) => {
+    const trancheVaultContract = await getTrancheVaultContractV2(poolName, trancheType, provider);
+    if (!trancheVaultContract || !assets) {
+        return undefined;
+    }
+    return trancheVaultContract.convertToShares(assets);
+};
+export const getTrancheSharesToAssetsV2 = async (poolName, trancheType, provider, shares) => {
+    const trancheVaultContract = await getTrancheVaultContractV2(poolName, trancheType, provider);
+    if (!trancheVaultContract || !shares) {
+        return undefined;
+    }
+    return trancheVaultContract.convertToAssets(shares);
+};
+export const getCreditHashV2 = (poolName, chainId, account) => {
+    if (!account) {
+        return undefined;
+    }
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    // Get keccak256 hash of the credit contract and account
+    return ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(['address', 'address'], [poolInfo.poolCredit, account]));
+};
+export const getCreditRecordV2 = async (poolName, chainId, account, provider) => {
+    if (!account) {
+        return undefined;
+    }
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    const creditContract = await getPoolCreditContractV2(poolName, provider);
+    if (!creditContract) {
+        return undefined;
+    }
+    const creditHash = getCreditHashV2(poolName, chainId, account);
+    if (!creditHash) {
+        return undefined;
+    }
+    return creditContract.getCreditRecord(creditHash);
+};
+export const getDueDetailV2 = async (poolName, chainId, account, provider) => {
+    if (!account) {
+        return undefined;
+    }
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    const creditContract = await getPoolCreditContractV2(poolName, provider);
+    if (!creditContract) {
+        return undefined;
+    }
+    const creditHash = getCreditHashV2(poolName, chainId, account);
+    if (!creditHash) {
+        return undefined;
+    }
+    return creditContract.getDueDetail(creditHash);
+};
+export const getCreditConfigV2 = async (poolName, chainId, account, provider) => {
+    if (!account) {
+        return undefined;
+    }
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    const creditManagerContract = await getPoolCreditManagerContractV2(poolName, provider);
+    if (!creditManagerContract) {
+        return undefined;
+    }
+    const creditHash = getCreditHashV2(poolName, chainId, account);
+    if (!creditHash) {
+        return undefined;
+    }
+    return creditManagerContract.getCreditConfig(creditHash);
+};
+export const getCurrentEpochInfoV2 = async (poolName, provider) => {
+    const epochManagerContract = await getEpochManagerContractV2(poolName, provider);
+    if (!epochManagerContract) {
+        return undefined;
+    }
+    return epochManagerContract.currentEpoch();
+};
+export const getPoolFeeStructureV2 = async (poolName, provider) => {
+    const poolConfigContract = await getPoolConfigContractV2(poolName, provider);
+    if (!poolConfigContract) {
+        return undefined;
+    }
+    const feeStructure = await poolConfigContract.getFeeStructure();
+    return {
+        yield: feeStructure.yieldInBps / BP_FACTOR.toNumber(),
+        minPrincipalRate: feeStructure.minPrincipalRateInBps / BP_FACTOR.toNumber(),
+        lateFee: feeStructure.lateFeeBps / BP_FACTOR.toNumber(),
+    };
+};
+// Please refer to: https://docs.google.com/spreadsheets/d/1Pkqj7pcJ6OxFG8ZTYQLAeAKf3ouD0mAzT9AKoH1ym4s/edit#gid=0
+export const getApyV2 = async (poolName, chainId, provider) => {
+    const poolInfo = getPoolInfoV2(poolName, chainId);
+    if (!poolInfo) {
+        return undefined;
+    }
+    const poolConfigContract = await getPoolConfigContractV2(poolName, provider);
+    if (!poolConfigContract) {
+        return undefined;
+    }
+    const getProtocolFeeInBps = async () => {
+        const humaConfig = await poolConfigContract.humaConfig();
+        const humaConfigContract = getContract(humaConfig, HUMA_CONFIG_ABI, provider);
+        return humaConfigContract.protocolFeeInBps();
+    };
+    const getFlcTotalAssetsAndTotalAssetsAfterRisk = async () => {
+        const flcConfigs = await Promise.all(Object.values(poolInfo.firstLossCovers)
+            .filter((firstLossCover) => firstLossCover !== ethers.constants.AddressZero)
+            .map((firstLossCover) => poolConfigContract.getFirstLossCoverConfig(firstLossCover)));
+        const result = {
+            flcTotalAssets: BigNumber.from(0),
+            flcTotalAssetsAfterRisk: BigNumber.from(0),
+        };
+        flcConfigs.forEach((flcConfig) => {
+            result.flcTotalAssets = result.flcTotalAssets.add(flcConfig.minLiquidity);
+            result.flcTotalAssetsAfterRisk = result.flcTotalAssetsAfterRisk.add(flcConfig.minLiquidity
+                .mul(flcConfig.riskYieldMultiplierInBps)
+                .div(BP_FACTOR));
+        });
+        return {
+            flcTotalAssets: result.flcTotalAssets.toNumber(),
+            flcTotalAssetsAfterRisk: result.flcTotalAssetsAfterRisk.toNumber(),
+        };
+    };
+    const [protocolFeeInBps, feeStructure, adminRnR, lpConfig, flcTotalAssetsAndTotalAssetsAfterRisk,] = await Promise.all([
+        getProtocolFeeInBps(),
+        poolConfigContract.getFeeStructure(),
+        poolConfigContract.getAdminRnR(),
+        poolConfigContract.getLPConfig(),
+        getFlcTotalAssetsAndTotalAssetsAfterRisk(),
+    ]);
+    const BP_FACTOR_NUMBER = BP_FACTOR.toNumber();
+    // APY = (1+APR/12)^12 - 1
+    const APY = (1 + feeStructure.yieldInBps / BP_FACTOR_NUMBER / 12) ** 12 - 1;
+    const poolCap = lpConfig.liquidityCap.toNumber();
+    const juniorAssets = poolCap / (lpConfig.maxSeniorJuniorRatio + 1);
+    const seniorAssets = poolCap - juniorAssets;
+    const totalProfit = poolCap * APY;
+    const postPoolProfitRatio = (1 - protocolFeeInBps / BP_FACTOR_NUMBER) *
+        (1 -
+            adminRnR.rewardRateInBpsForPoolOwner / BP_FACTOR_NUMBER -
+            adminRnR.rewardRateInBpsForPoolOwner / BP_FACTOR_NUMBER);
+    const poolPostProfit = totalProfit * postPoolProfitRatio;
+    let seniorTrancheApy = 0;
+    let seniorPostProfit = 0;
+    if (lpConfig.fixedSeniorYieldInBps > 0) {
+        seniorTrancheApy = lpConfig.fixedSeniorYieldInBps / BP_FACTOR_NUMBER;
+        seniorPostProfit = poolPostProfit - seniorAssets * seniorTrancheApy;
+    }
+    else {
+        const riskAdjustment = lpConfig.tranchesRiskAdjustmentInBps / BP_FACTOR_NUMBER;
+        const seniorProfit = seniorAssets * (postPoolProfitRatio * (1 - riskAdjustment) * APY);
+        seniorTrancheApy = postPoolProfitRatio * (1 - riskAdjustment) * APY;
+        seniorPostProfit = poolPostProfit - seniorProfit;
+    }
+    const { flcTotalAssets, flcTotalAssetsAfterRisk } = flcTotalAssetsAndTotalAssetsAfterRisk;
+    const weight = juniorAssets + flcTotalAssetsAfterRisk;
+    const juniorProfit = (juniorAssets / weight) * seniorPostProfit;
+    const juniorTrancheApy = juniorProfit / juniorAssets;
+    const flcProfit = (flcTotalAssetsAfterRisk / weight) * seniorPostProfit;
+    const firstLossCoverApy = flcProfit / flcTotalAssets;
+    return {
+        seniorTrancheApy,
+        juniorTrancheApy,
+        firstLossCoverApy,
+    };
+};
+//# sourceMappingURL=poolContract.js.map