impermax-sdk 1.0.1 → 1.0.2

package/lib/esm/impermax-router/PoolToken.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ether_utils_1 = require("../utils/ether-utils");
+class PoolToken {
+    constructor(lendingPool, poolTokenType) {
+        this.cache = {};
+        this.getContractHelper = () => this.lendingPool.factory.router.contractsHelper;
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    getSubgraphPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.lendingPool.getSubgraphLendingPool();
+            return lendingPool.poolTokens[this.poolTokenType];
+        });
+    }
+    getPoolTokenAddressFromLendingPool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.lendingPool.getPoolTokenAddresses())[this.poolTokenType];
+        });
+    }
+    getPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.poolToken)
+                this.cache.poolToken = this.initializePoolToken();
+            return this.cache.poolToken;
+        });
+    }
+    getPoolTokenAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getPoolToken())._address;
+        });
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.token)
+                this.cache.token = this.initializeToken();
+            return this.cache.token;
+        });
+    }
+    getTokenAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getToken())._address;
+        });
+    }
+    getDecimals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subgraph = yield this.getSubgraphPoolToken();
+            return yield subgraph.getDecimals();
+        });
+    }
+    // Utilities
+    normalize(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return amount / Math.pow(10, yield this.getDecimals());
+        });
+    }
+    toBigNumber(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, utils_1.isValidNumber)(amount))
+                return null;
+            return (0, ether_utils_1.decimalToBalance)(amount, yield this.getDecimals());
+        });
+    }
+    toNumber(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!amount)
+                return null;
+            return parseFloat(amount.toString()) / Math.pow(10, yield this.getDecimals());
+        });
+    }
+    toTokens(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, utils_1.isValidNumber)(amount))
+                return null;
+            const exchangeRate = yield this.getExchangeRate();
+            return (0, ether_utils_1.decimalToBalance)(amount / exchangeRate, yield this.getDecimals());
+        });
+    }
+    fromTokens(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!amount)
+                return null;
+            const exchangeRate = yield this.getExchangeRate();
+            return parseFloat(amount.toString()) * exchangeRate / Math.pow(10, yield this.getDecimals());
+        });
+    }
+    // Total balance
+    initializeTotalBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken();
+            const amount = yield poolToken.methods.totalBalance().call();
+            return this.normalize(amount);
+        });
+    }
+    getTotalBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.totalBalance)
+                this.cache.totalBalance = this.initializeTotalBalance();
+            return this.cache.totalBalance;
+        });
+    }
+    getTotalBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBalance = yield this.getTotalBalance();
+            const subgraph = yield this.getSubgraphPoolToken();
+            const tokenPrice = yield subgraph.getTokenPriceFast();
+            return totalBalance * tokenPrice;
+        });
+    }
+    // Exchange rate
+    initializeExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken();
+            let exchangeRate = (yield poolToken.methods.exchangeRate().call()) / 1e18;
+            return exchangeRate;
+        });
+    }
+    getExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.exchangeRate)
+                this.cache.exchangeRate = this.initializeExchangeRate();
+            return this.cache.exchangeRate;
+        });
+    }
+}
+exports.default = PoolToken;

package/lib/esm/impermax-router/index.d.ts

@@ -0,0 +1,20 @@
+import { ImpermaxRouterCfg } from "./interfaces";
+import Subgraph from "../subgraph";
+import ContractsHelper from "./ContractsHelper";
+import ImpermaxFactory from "./ImpermaxFactory";
+import { Factory, FactoryIndex, Networks } from '../config/types';
+export default class ImpermaxRouter {
+    network: Networks;
+    subgraph: Subgraph;
+    web3: any;
+    chainId: number;
+    contractsHelper: ContractsHelper;
+    factories: FactoryIndex<ImpermaxFactory>;
+    uiMargin: number;
+    dust: number;
+    priceInverted: boolean;
+    constructor(cfg: ImpermaxRouterCfg);
+    cleanCache(): void;
+    setPriceInverted(priceInverted: boolean): void;
+    getFactory(factory: Factory): ImpermaxFactory;
+}

package/lib/esm/impermax-router/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContractsHelper_1 = __importDefault(require("./ContractsHelper"));
+const ImpermaxFactory_1 = __importDefault(require("./ImpermaxFactory"));
+class ImpermaxRouter {
+    constructor(cfg) {
+        this.network = cfg.network;
+        this.subgraph = cfg.subgraph;
+        this.web3 = cfg.web3;
+        this.chainId = cfg.chainId;
+        this.uiMargin = 1.1;
+        this.dust = 1.000001;
+        this.priceInverted = cfg.priceInverted;
+        this.contractsHelper = new ContractsHelper_1.default(this);
+        this.factories = {};
+    }
+    cleanCache() {
+        for (const factory of Object.keys(this.factories)) {
+            this.factories[factory].cleanCache();
+        }
+    }
+    setPriceInverted(priceInverted) {
+        this.priceInverted = priceInverted;
+    }
+    getFactory(factory) {
+        if (!this.factories[factory])
+            this.factories[factory] = new ImpermaxFactory_1.default(this, factory);
+        return this.factories[factory];
+    }
+}
+exports.default = ImpermaxRouter;

package/lib/esm/impermax-router/interfaces.d.ts

@@ -0,0 +1,218 @@
+import { BigNumber } from "ethers";
+import Subgraph from "../subgraph";
+import { Address, Networks, PoolTokenType } from '../config/types';
+export type Contract = any;
+export type RouterContract = Contract;
+export type FactoryContract = Contract;
+export type SimpleUniswapOracleContract = Contract;
+export type ERC20Contract = Contract;
+export type UniswapV2PairContract = Contract;
+export type UniswapV2FactoryContract = Contract;
+export type BorrowableContract = Contract;
+export type CollateralContract = Contract;
+export type MerkleDistributorContract = Contract;
+export type FarmingPoolContract = Contract;
+export type ClaimAggregatorContract = Contract;
+export type ClaimableContract = Contract;
+export type StakedLPTokenContract = Contract;
+export type ImpermaxChefContract = Contract;
+export type LendingPool = {
+    uniswapV2Pair: UniswapV2PairContract;
+    tokenA: ERC20Contract;
+    tokenB: ERC20Contract;
+    collateral: CollateralContract;
+    borrowableA: BorrowableContract;
+    borrowableB: BorrowableContract;
+    farmingPoolA: FarmingPoolContract;
+    farmingPoolB: FarmingPoolContract;
+    stakedLPToken: StakedLPTokenContract;
+};
+export declare enum ApprovalType {
+    POOL_TOKEN = 0,
+    UNDERLYING = 1,
+    BORROW = 2
+}
+export interface PermitData {
+    permitData: string;
+    amount: BigNumber;
+    deadline: BigNumber;
+}
+export interface Changes {
+    changeBorrowedA: number;
+    changeBorrowedB: number;
+    changeCollateral: number;
+}
+export declare const NO_CHANGES: {
+    changeBorrowedA: number;
+    changeBorrowedB: number;
+    changeCollateral: number;
+};
+export interface Values {
+    valueCollateral: number;
+    valueA: number;
+    valueB: number;
+}
+export interface ImpermaxRouterCfg {
+    network: Networks;
+    subgraph: Subgraph;
+    web3: any;
+    chainId: number;
+    priceInverted: boolean;
+}
+export interface PoolTokenData {
+    id: Address;
+    totalBalance: string;
+    exchangeRate: string;
+    totalBalanceUSD: string;
+}
+export interface BorrowableData extends PoolTokenData {
+    underlying: TokenData;
+    totalBorrows: string;
+    borrowRate: string;
+    reserveFactor: string;
+    kinkBorrowRate: string;
+    kinkUtilizationRate: string;
+    borrowIndex: string;
+    accrualTimestamp: string;
+    farmingPool: FarmingPoolData;
+    rewards?: Array<{
+        rewardToken: Address;
+        rewardRate: number;
+    }>;
+}
+export interface CollateralData extends PoolTokenData {
+    safetyMargin: string;
+    liquidationIncentive: string;
+    liquidationFee: string;
+}
+export interface BorrowablePastData {
+    borrowIndex: string;
+    accrualTimestamp: string;
+    exchangeRate: string;
+}
+export interface TokenData {
+    id: Address;
+    symbol: string;
+    name: string;
+    decimals: string;
+    derivedUSD: string;
+}
+export interface RewardData {
+    id: Address;
+    rewardRate: string;
+    rewardsToken: TokenData;
+    periodFinish: string;
+}
+export interface PairData {
+    id: Address;
+    factory: string;
+    reserve0: string;
+    reserve1: string;
+    totalSupply: string;
+    reserveUSD: string;
+    token0Price: string;
+    token1Price: string;
+    derivedUSD: string;
+    uniswapV2PairAddress: string;
+    uniswapV2Factory: string;
+    isStakedLPToken: boolean;
+    exchangeRate: string;
+    stakingRewards: string;
+    masterChef: string;
+    pid: string;
+    stakedTotalSupply: string;
+    rewards: Array<RewardData>;
+    uniswapAPR: number;
+}
+export interface FarmingPoolData {
+    epochAmount: string;
+    epochBegin: string;
+    segmentLength: string;
+    vestingBegin: string;
+    sharePercentage: string;
+}
+export interface LendingPoolPastData {
+    [PoolTokenType.Collateral]: undefined;
+    [PoolTokenType.BorrowableA]: BorrowablePastData;
+    [PoolTokenType.BorrowableB]: BorrowablePastData;
+}
+export interface LendingPoolData {
+    id: Address;
+    [PoolTokenType.Collateral]: CollateralData;
+    [PoolTokenType.BorrowableA]: BorrowableData;
+    [PoolTokenType.BorrowableB]: BorrowableData;
+    pair: PairData;
+    past24h?: LendingPoolPastData;
+    past7d?: LendingPoolPastData;
+}
+export interface CollateralPosition {
+    balance: string;
+    collateral: {
+        lendingPool: {
+            id: Address;
+        };
+    };
+}
+export interface SupplyPosition {
+    balance: string;
+    borrowable: {
+        underlying: {
+            id: Address;
+        };
+        lendingPool: {
+            id: Address;
+        };
+    };
+}
+export interface BorrowPosition {
+    borrowBalance: string;
+    borrowIndex: string;
+    borrowable: {
+        underlying: {
+            id: Address;
+        };
+        lendingPool: {
+            id: Address;
+        };
+    };
+}
+export interface UserData {
+    collateralPositions: {
+        [key in Address]: CollateralPosition;
+    };
+    supplyPositions: {
+        [key in Address]: {
+            [key in PoolTokenType]?: SupplyPosition;
+        };
+    };
+    borrowPositions: {
+        [key in Address]: {
+            [key in PoolTokenType]?: BorrowPosition;
+        };
+    };
+}
+export interface TvlData {
+    crossChainTVLUSD: number;
+    totalBalanceUSD: number;
+    totalBorrowsUSD: number;
+    totalSupplyUSD: number;
+}
+export interface AirdropData {
+    index: number;
+    amount: BigNumber;
+    proof: Array<string>;
+}
+export interface ClaimEvent {
+    amount: number;
+    transactionHash: string;
+}
+export interface XimxData {
+    totalSupply: string;
+    totalBalance: string;
+    exchangeRate: string;
+    dailyAPR: string;
+}
+export interface PendingRewardUI {
+    symbol: string;
+    amount: number;
+}

package/lib/esm/impermax-router/interfaces.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_CHANGES = exports.ApprovalType = void 0;
+const types_1 = require("../config/types");
+var ApprovalType;
+(function (ApprovalType) {
+    ApprovalType[ApprovalType["POOL_TOKEN"] = 0] = "POOL_TOKEN";
+    ApprovalType[ApprovalType["UNDERLYING"] = 1] = "UNDERLYING";
+    ApprovalType[ApprovalType["BORROW"] = 2] = "BORROW";
+})(ApprovalType = exports.ApprovalType || (exports.ApprovalType = {}));
+exports.NO_CHANGES = {
+    changeBorrowedA: 0,
+    changeBorrowedB: 0,
+    changeCollateral: 0,
+};

package/{index.ts → lib/esm/index.d.ts}

@@ -1,5 +1,3 @@
 import Subgraph from './subgraph';
 import ImpermaxRouter from './impermax-router';
-
-exports.Subgraph = Subgraph;
-exports.ImpermaxRouter = ImpermaxRouter;
+export { Subgraph, ImpermaxRouter, };

package/lib/esm/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpermaxRouter = exports.Subgraph = void 0;
+const subgraph_1 = __importDefault(require("./subgraph"));
+exports.Subgraph = subgraph_1.default;
+const impermax_router_1 = __importDefault(require("./impermax-router"));
+exports.ImpermaxRouter = impermax_router_1.default;

package/lib/esm/subgraph/Account.d.ts

@@ -0,0 +1,18 @@
+import { UserData } from "../impermax-router/interfaces";
+import Subgraph from "./index";
+import AccountLendingPool from "./AccountLendingPool";
+import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+export default class Account {
+    subgraph: Subgraph;
+    account: Address;
+    accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
+    constructor(subgraph: Subgraph, account: Address);
+    private initializeAccountLendingPool;
+    getAccountLendingPool(factory: Factory, pair: Address): Promise<AccountLendingPool>;
+    getUserData(): Promise<FactoryIndex<UserData>>;
+    getBorrowPositions(): Promise<FactoryIndex<Address[]>>;
+    getSupplyPositions(): Promise<FactoryIndex<Address[]>>;
+    getAccountTotalValueLocked(): Promise<number>;
+    getAccountTotalValueSupplied(): Promise<number>;
+    getAccountTotalValueBorrowed(): Promise<number>;
+}

package/lib/esm/subgraph/Account.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AccountLendingPool_1 = __importDefault(require("./AccountLendingPool"));
+const types_1 = require("../config/types");
+class Account {
+    constructor(subgraph, account) {
+        this.subgraph = subgraph;
+        this.account = account;
+        this.accountLLPs = {};
+    }
+    initializeAccountLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.subgraph.getLendingPool(factory, pair);
+            return new AccountLendingPool_1.default(this, lendingPool);
+        });
+    }
+    getAccountLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountLLPs[factory])
+                this.accountLLPs[factory] = {};
+            if (!this.accountLLPs[factory][pair])
+                this.accountLLPs[factory][pair] = this.initializeAccountLendingPool(factory, pair);
+            return this.accountLLPs[factory][pair];
+        });
+    }
+    getUserData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.subgraph.getUserData(this.account);
+        });
+    }
+    getBorrowPositions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const userData = yield this.getUserData();
+            for (const factory of Object.keys(userData)) {
+                result[factory] = Object.keys(userData[factory].collateralPositions);
+            }
+            return result;
+        });
+    }
+    getSupplyPositions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const userData = yield this.getUserData();
+            for (const factory of Object.keys(userData)) {
+                result[factory] = Object.keys(userData[factory].supplyPositions);
+            }
+            return result;
+        });
+    }
+    getAccountTotalValueLocked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowPositions = yield this.getBorrowPositions();
+            const supplyPositions = yield this.getSupplyPositions();
+            let tvl = 0;
+            for (const factory of Object.keys(borrowPositions)) {
+                for (const uniswapV2PairAddress of borrowPositions[factory]) {
+                    const accountLendingPool = yield this.getAccountLendingPool(factory, uniswapV2PairAddress);
+                    tvl += yield accountLendingPool.getBorrowerEquityValue();
+                }
+                for (const uniswapV2PairAddress of supplyPositions[factory]) {
+                    const accountLendingPool = yield this.getAccountLendingPool(factory, uniswapV2PairAddress);
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableA].getSuppliedValue();
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableB].getSuppliedValue();
+                }
+            }
+            return tvl;
+        });
+    }
+    getAccountTotalValueSupplied() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyPositions = yield this.getSupplyPositions();
+            let tvl = 0;
+            for (const factory of Object.keys(supplyPositions)) {
+                for (const uniswapV2PairAddress of supplyPositions[factory]) {
+                    const accountLendingPool = yield this.getAccountLendingPool(factory, uniswapV2PairAddress);
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableA].getSuppliedValue();
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableB].getSuppliedValue();
+                }
+            }
+            return tvl;
+        });
+    }
+    getAccountTotalValueBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowPositions = yield this.getBorrowPositions();
+            let tvl = 0;
+            for (const factory of Object.keys(borrowPositions)) {
+                for (const uniswapV2PairAddress of borrowPositions[factory]) {
+                    const accountLendingPool = yield this.getAccountLendingPool(factory, uniswapV2PairAddress);
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableA].getBorrowedValue();
+                    tvl += yield accountLendingPool.accountPoolTokens[types_1.PoolTokenType.BorrowableB].getBorrowedValue();
+                }
+            }
+            return tvl;
+        });
+    }
+}
+exports.default = Account;

package/lib/esm/subgraph/AccountLendingPool.d.ts

@@ -0,0 +1,19 @@
+import { CollateralPosition, UserData } from "../impermax-router/interfaces";
+import Account from "./Account";
+import AccountPoolToken from "./AccountPoolToken";
+import LendingPool from "./LendingPool";
+import { PoolTokenType } from '../config/types';
+export default class AccountLendingPool {
+    account: Account;
+    lendingPool: LendingPool;
+    accountPoolTokens: {
+        [key in PoolTokenType]?: AccountPoolToken;
+    };
+    constructor(account: Account, lendingPool: LendingPool);
+    getAccountPoolToken(poolTokenType: PoolTokenType): AccountPoolToken;
+    getUserData(): Promise<UserData>;
+    getCollateralPosition(): Promise<CollateralPosition>;
+    getCollateralAmount(): Promise<number>;
+    getCollateralValue(): Promise<number>;
+    getBorrowerEquityValue(): Promise<number>;
+}

package/lib/esm/subgraph/AccountLendingPool.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AccountPoolToken_1 = __importDefault(require("./AccountPoolToken"));
+const types_1 = require("../config/types");
+class AccountLendingPool {
+    constructor(account, lendingPool) {
+        this.account = account;
+        this.lendingPool = lendingPool;
+        this.accountPoolTokens = {};
+        this.accountPoolTokens[types_1.PoolTokenType.Collateral] = new AccountPoolToken_1.default(this, types_1.PoolTokenType.Collateral);
+        this.accountPoolTokens[types_1.PoolTokenType.BorrowableA] = new AccountPoolToken_1.default(this, types_1.PoolTokenType.BorrowableA);
+        this.accountPoolTokens[types_1.PoolTokenType.BorrowableB] = new AccountPoolToken_1.default(this, types_1.PoolTokenType.BorrowableB);
+    }
+    getAccountPoolToken(poolTokenType) {
+        return this.accountPoolTokens[poolTokenType];
+    }
+    getUserData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.account.getUserData();
+            if (!userData)
+                return null;
+            return userData[this.lendingPool.factory];
+        });
+    }
+    getCollateralPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.getUserData();
+            if (!userData)
+                return null;
+            return userData.collateralPositions[this.lendingPool.pairAddress];
+        });
+    }
+    getCollateralAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralPosition = yield this.getCollateralPosition();
+            if (!collateralPosition)
+                return 0;
+            const exchangeRate = yield this.lendingPool.poolTokens[types_1.PoolTokenType.Collateral].getExchangeRate();
+            const collateralBalance = parseFloat(collateralPosition.balance);
+            return collateralBalance * exchangeRate;
+        });
+    }
+    getCollateralValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenPrice = yield this.lendingPool.poolTokens[types_1.PoolTokenType.Collateral].getTokenPriceAccurate();
+            const collateralAmount = yield this.getCollateralAmount();
+            return collateralAmount * tokenPrice;
+        });
+    }
+    getBorrowerEquityValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralValue = yield this.getCollateralValue();
+            const borrowedValueA = yield this.accountPoolTokens[types_1.PoolTokenType.BorrowableA].getBorrowedValue();
+            const borrowedValueB = yield this.accountPoolTokens[types_1.PoolTokenType.BorrowableB].getBorrowedValue();
+            return collateralValue - borrowedValueA - borrowedValueB;
+        });
+    }
+}
+exports.default = AccountLendingPool;

package/lib/esm/subgraph/AccountPoolToken.d.ts

@@ -0,0 +1,14 @@
+import AccountLendingPool from "./AccountLendingPool";
+import PoolToken from "./PoolToken";
+import { PoolTokenType } from '../config/types';
+export default class AccountPoolToken {
+    accountLendingPool: AccountLendingPool;
+    poolToken: PoolToken;
+    constructor(accountLendingPool: AccountLendingPool, poolTokenType: PoolTokenType);
+    private getBorrowPosition;
+    private getSupplyPosition;
+    getBorrowedAmount(): Promise<number>;
+    getBorrowedValue(): Promise<number>;
+    getSuppliedAmount(): Promise<number>;
+    getSuppliedValue(): Promise<number>;
+}