impermax-sdk 1.0.3 → 1.0.5

package/lib/config/farms.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFarmByStakedLPFactory = exports.STAKED_LP_FACTORY = exports.hrFarms = exports.Farms = void 0;
+const types_1 = require("./types");
+var Farms;
+(function (Farms) {
+    Farms["quickswapOld"] = "quickswapOld";
+    Farms["quickswap"] = "quickswap";
+    Farms["quickswapDual"] = "quickswapDual";
+    Farms["sushiswap"] = "sushiswap";
+    Farms["arbinyan"] = "arbinyan";
+    Farms["swapr"] = "swapr";
+    Farms["swapfish"] = "swapfish";
+    Farms["zyberswap"] = "zyberswap";
+    Farms["radiant"] = "";
+    Farms["plutusDao"] = "";
+    Farms["pangolin"] = "pangolin";
+    Farms["pangolinV2"] = "pangolinV2";
+    Farms["traderJoeV2"] = "traderJoeV2";
+    Farms["traderJoeV3"] = "traderJoeV3";
+    Farms["traderJoeV4"] = "traderJoeV4";
+    Farms["solarbeam"] = "solarbeam";
+    Farms["solarbeam2"] = "solarbeam2";
+    Farms["thorus"] = "thorus";
+    Farms["tetuswap"] = "tetuswap";
+    Farms["solidex"] = "solidex";
+    Farms["solidexB"] = "solidexB";
+    Farms["solidexUSDC"] = "solidexUSDC";
+    Farms["solidexUSDCB"] = "solidexUSDCB";
+    Farms["oxdao"] = "oxdao";
+})(Farms = exports.Farms || (exports.Farms = {}));
+exports.hrFarms = {
+    [Farms.quickswapOld]: 'QuickSwap',
+    [Farms.quickswap]: 'QuickSwap',
+    [Farms.quickswapDual]: 'QuickSwap',
+    [Farms.sushiswap]: 'SushiSwap',
+    [Farms.arbinyan]: 'ArbyNYAN',
+    [Farms.swapr]: 'Swapr',
+    [Farms.swapfish]: 'SwapFish',
+    [Farms.zyberswap]: 'ZyberSwap',
+    [Farms.radiant]: 'Radiant',
+    [Farms.plutusDao]: 'Plutus DAO',
+    [Farms.pangolin]: 'Pangolin',
+    [Farms.pangolinV2]: 'Pangolin',
+    [Farms.traderJoeV2]: 'TraderJoe',
+    [Farms.traderJoeV3]: 'TraderJoe',
+    [Farms.traderJoeV4]: 'TraderJoe',
+    [Farms.solarbeam]: 'Solarbeam',
+    [Farms.solarbeam2]: 'Solarbeam',
+    [Farms.thorus]: 'Thorus',
+    [Farms.tetuswap]: 'TetuSwap',
+    [Farms.solidex]: 'Solidex',
+    [Farms.solidexB]: 'Solidex',
+    [Farms.solidexUSDC]: 'Solidex',
+    [Farms.solidexUSDCB]: 'Solidex',
+    [Farms.oxdao]: '0xDAO',
+};
+exports.STAKED_LP_FACTORY = {
+    [types_1.Networks.Ropsten]: {},
+    [types_1.Networks.Mainnet]: {},
+    [types_1.Networks.Polygon]: {
+        [Farms.quickswapOld]: '0xF47B652cDE9b30D6aDd0b13027Bb7AD2F7AF04f4',
+        [Farms.quickswap]: '0x846019FB6f136fC98b80e527C3d34F39D16a38c4',
+        [Farms.quickswapDual]: '0xC4505Cc6125d61E2A352ce5cf2129f2fb19259a8',
+        [Farms.sushiswap]: '0xcb30A66e72Ed90D1b34f78fc0655895FC28bB6CF',
+        [Farms.tetuswap]: '0x8E45622663Bb01dc285B4F51Eb8F9FE4fa7b5899',
+    },
+    [types_1.Networks.Arbitrum]: {
+        [Farms.arbinyan]: '0x6659a9c5cD313974343E30b4fDfFD95bD4b4dCd2',
+        [Farms.sushiswap]: '0x270250F59C1ffA06C9e3234D528858Ff59aFCE68',
+        [Farms.swapr]: '0x5643C3aCEC0D4970a385fb9Cc1555bec1d912bb8',
+        //[Farms.swapfish]: '0xcDAeC65495Fa5c0545c5a405224214e3594f30d8',
+        [Farms.swapfish]: '0x3bE7B59Ab6558845FfA1f026Dff40b305dd47b37',
+        [Farms.zyberswap]: '0xBCE93e2D822CfDD70F106e32FCB266457cece45F',
+        [Farms.radiant]: '0x4aE11dC7D7e70eE16d7eaE32851302e55f6CA85e',
+        [Farms.plutusDao]: '0x4dC48B93855F42cCcc54f65615AeF6FFC12EC1DF',
+    },
+    [types_1.Networks.Avalanche]: {
+        [Farms.pangolin]: '0xBB92270716C8c424849F17cCc12F4F24AD4064D6',
+        [Farms.pangolinV2]: '0xC596f6455054D8cdDE627096bE671e377791E295',
+        [Farms.traderJoeV2]: '0x16ED59ffbfbe62ebA9a69a304D38901F86461282',
+        [Farms.traderJoeV3]: '0x58Fde5bdB2C6Bd828Bc41c12a68189C7cd93dCE2',
+        [Farms.traderJoeV4]: '0xbc1bb900e34adbb99957672361433c6ad62a0cac',
+        [Farms.thorus]: '0x9141B3d02443a84793794f661Ae1e6607A03A201',
+    },
+    [types_1.Networks.Moonriver]: {
+        [Farms.sushiswap]: '0xBB92270716C8c424849F17cCc12F4F24AD4064D6',
+        [Farms.solarbeam]: '0x95887654d8646c26fab33f344576e2e74b211256',
+        [Farms.solarbeam2]: '0x23bdECdB7073D5f899708f33FCaFff787b81e287',
+    },
+    [types_1.Networks.Aurora]: {},
+    [types_1.Networks.Cronos]: {},
+    [types_1.Networks.Fantom]: {
+        [Farms.solidex]: '0x95887654d8646C26fAb33F344576E2E74b211256',
+        [Farms.solidexB]: '0x8610Dc1912a55761a713D827a1a1ad131bE8f579',
+        [Farms.solidexUSDC]: '0xF14f98E6F34C12Bd74fcEAC1668aF749fc269cFf',
+        [Farms.solidexUSDCB]: '0x9B1434a02Ee86302d463bB6B365EbdFAc56e067A',
+        [Farms.oxdao]: '0xB83D21F60B73B21506c69DEcdBcF7Ab5AB737eB2',
+    },
+    [types_1.Networks.Harmony]: {},
+    [types_1.Networks.Moonbeam]: {},
+    [types_1.Networks.Sxnetwork]: {},
+};
+function getFarmByStakedLPFactory(network, address) {
+    if (!address)
+        return null;
+    for (const farm of Object.keys(Farms)) {
+        if (exports.STAKED_LP_FACTORY[network][farm] &&
+            address.toLowerCase() == exports.STAKED_LP_FACTORY[network][farm].toLowerCase())
+            return farm;
+    }
+    return null;
+}
+exports.getFarmByStakedLPFactory = getFarmByStakedLPFactory;

package/lib/config/general.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from 'ethers';
+export declare const NOT_SYNCED = false;
+export declare const DEADLINE: BigNumber;
+export declare const ZERO: BigNumber;
+export declare const APPROVE_AMOUNT: BigNumber;

package/lib/config/general.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPROVE_AMOUNT = exports.ZERO = exports.DEADLINE = exports.NOT_SYNCED = void 0;
+const ethers_1 = require("ethers");
+exports.NOT_SYNCED = false;
+exports.DEADLINE = ethers_1.BigNumber.from(Math.floor(Date.now() / 1000) + 3600 * 24 * 365); //1 year deadline
+exports.ZERO = ethers_1.ethers.constants.Zero;
+exports.APPROVE_AMOUNT = ethers_1.ethers.constants.MaxUint256;

package/lib/config/subgraphs.d.ts

@@ -0,0 +1,5 @@
+import { Address, NetworkFactoryIndex, NetworkIndex } from './types';
+export declare const IMPERMAX_SUBGRAPH_URL: NetworkFactoryIndex<Address>;
+export declare const IMPERMAX_CHEF_SUBGRAPH_URL: NetworkIndex<string>;
+export declare const BLOCKS_SUBGRAPH_URL: NetworkIndex<string>;
+export declare const XIMX_SUBGRAPH_URL = "https://api.thegraph.com/subgraphs/name/impermax-finance/imx-staking";

package/lib/config/subgraphs.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XIMX_SUBGRAPH_URL = exports.BLOCKS_SUBGRAPH_URL = exports.IMPERMAX_CHEF_SUBGRAPH_URL = exports.IMPERMAX_SUBGRAPH_URL = void 0;
+const types_1 = require("./types");
+exports.IMPERMAX_SUBGRAPH_URL = {
+    [types_1.Networks.Ropsten]: {
+        [types_1.Factory.V2V1]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-ropsten'
+    },
+    [types_1.Networks.Mainnet]: {
+        [types_1.Factory.V2V1]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap1'
+    },
+    [types_1.Networks.Polygon]: {
+        [types_1.Factory.V2V1_1]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-polygon',
+        [types_1.Factory.V2V2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-polygon-v2',
+    },
+    [types_1.Networks.Arbitrum]: {
+        [types_1.Factory.V2V1_1]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-arbitrum',
+        [types_1.Factory.V2V2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-arbitrum-v2',
+        //[F.V2V1_1]: 'https://api.impermax.finance/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-arbitrum02'
+    },
+    [types_1.Networks.Avalanche]: {
+        [types_1.Factory.V2V1_2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-avalanche1',
+        [types_1.Factory.V2V2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-avalanche-v2',
+    },
+    [types_1.Networks.Moonriver]: {
+        [types_1.Factory.V2V1_2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-moonriver'
+    },
+    [types_1.Networks.Aurora]: {
+        [types_1.Factory.V2V1_2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-aurora'
+    },
+    [types_1.Networks.Cronos]: {},
+    [types_1.Networks.Fantom]: {
+        [types_1.Factory.SOLV1_2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-fantom',
+        //[Factory.SOLV2]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-x-uniswap-v2-fantom-v2',
+    },
+    [types_1.Networks.Harmony]: {},
+    [types_1.Networks.Moonbeam]: {},
+    [types_1.Networks.Sxnetwork]: {},
+};
+exports.IMPERMAX_CHEF_SUBGRAPH_URL = {
+    [types_1.Networks.Ropsten]: '',
+    [types_1.Networks.Mainnet]: '',
+    [types_1.Networks.Polygon]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-chef-polygon',
+    [types_1.Networks.Arbitrum]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-chef-arbitrum',
+    [types_1.Networks.Avalanche]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-chef-avalanche',
+    [types_1.Networks.Moonriver]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-chef-moonriver',
+    [types_1.Networks.Fantom]: 'https://api.thegraph.com/subgraphs/name/impermax-finance/impermax-chef-fantom',
+    [types_1.Networks.Aurora]: '',
+    [types_1.Networks.Cronos]: '',
+    [types_1.Networks.Harmony]: '',
+    [types_1.Networks.Moonbeam]: '',
+    [types_1.Networks.Sxnetwork]: '',
+};
+exports.BLOCKS_SUBGRAPH_URL = {
+    [types_1.Networks.Ropsten]: '',
+    [types_1.Networks.Mainnet]: 'https://api.thegraph.com/subgraphs/name/blocklytics/ethereum-blocks',
+    [types_1.Networks.Polygon]: 'https://api.thegraph.com/subgraphs/name/matthewlilley/polygon-blocks',
+    [types_1.Networks.Arbitrum]: 'https://api.thegraph.com/subgraphs/name/sushiswap/arbitrum-blocks',
+    [types_1.Networks.Avalanche]: 'https://api.thegraph.com/subgraphs/name/dasconnor/avalanche-blocks',
+    [types_1.Networks.Moonriver]: 'https://api.thegraph.com/subgraphs/name/sushiswap/moonriver-blocks',
+    [types_1.Networks.Aurora]: '',
+    [types_1.Networks.Cronos]: '',
+    [types_1.Networks.Fantom]: 'https://api.thegraph.com/subgraphs/name/matthewlilley/fantom-blocks',
+    [types_1.Networks.Harmony]: '',
+    [types_1.Networks.Moonbeam]: '',
+    [types_1.Networks.Sxnetwork]: '',
+};
+exports.XIMX_SUBGRAPH_URL = "https://api.thegraph.com/subgraphs/name/impermax-finance/imx-staking";

package/lib/config/types.d.ts

@@ -0,0 +1,49 @@
+import { Amms } from './amms';
+export declare enum Networks {
+    Ropsten = "ropsten",
+    Mainnet = "mainnet",
+    Polygon = "polygon",
+    Arbitrum = "arbitrum",
+    Avalanche = "avalanche",
+    Moonriver = "moonriver",
+    Aurora = "aurora",
+    Cronos = "cronos",
+    Fantom = "fantom",
+    Harmony = "harmony",
+    Moonbeam = "moonbeam",
+    Sxnetwork = "sxnetwork"
+}
+export declare enum Factory {
+    V2V1 = "1",
+    V2V1_1 = "2",
+    V2V1_2 = "3",
+    V2V2 = "4",
+    SOLV1_2 = "5",
+    SOLV2 = "6"
+}
+export declare enum PoolTokenType {
+    Collateral = "collateral",
+    BorrowableA = "borrowable0",
+    BorrowableB = "borrowable1"
+}
+export type Address = string;
+export type NetworkIndex<Type> = {
+    [key in Networks]?: Type;
+};
+export type FactoryIndex<Type> = {
+    [key in Factory]?: Type;
+};
+export type AddressIndex<Type> = {
+    [key in Address]: Type;
+};
+export type NetworkFactoryIndex<Type> = NetworkIndex<FactoryIndex<Type>>;
+export type LendingPoolIndex<Type> = FactoryIndex<AddressIndex<Type>>;
+export type AmmIndex = {
+    [key in Networks]: {
+        [key in Amms]?: any;
+    };
+};
+export type DistributorDetails = {
+    claimableAddress: Address;
+    name: string;
+};

package/lib/config/types.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolTokenType = exports.Factory = exports.Networks = void 0;
+var Networks;
+(function (Networks) {
+    Networks["Ropsten"] = "ropsten";
+    Networks["Mainnet"] = "mainnet";
+    Networks["Polygon"] = "polygon";
+    Networks["Arbitrum"] = "arbitrum";
+    Networks["Avalanche"] = "avalanche";
+    Networks["Moonriver"] = "moonriver";
+    Networks["Aurora"] = "aurora";
+    Networks["Cronos"] = "cronos";
+    Networks["Fantom"] = "fantom";
+    Networks["Harmony"] = "harmony";
+    Networks["Moonbeam"] = "moonbeam";
+    Networks["Sxnetwork"] = "sxnetwork";
+})(Networks = exports.Networks || (exports.Networks = {}));
+// FACTORIES
+var Factory;
+(function (Factory) {
+    Factory["V2V1"] = "1";
+    Factory["V2V1_1"] = "2";
+    Factory["V2V1_2"] = "3";
+    Factory["V2V2"] = "4";
+    Factory["SOLV1_2"] = "5";
+    Factory["SOLV2"] = "6";
+})(Factory = exports.Factory || (exports.Factory = {}));
+var PoolTokenType;
+(function (PoolTokenType) {
+    PoolTokenType["Collateral"] = "collateral";
+    PoolTokenType["BorrowableA"] = "borrowable0";
+    PoolTokenType["BorrowableB"] = "borrowable1";
+})(PoolTokenType = exports.PoolTokenType || (exports.PoolTokenType = {}));

package/lib/impermax-router/Account.d.ts

@@ -0,0 +1,31 @@
+import { AirdropData, PendingRewardUI } from "./types";
+import ImpermaxRouter from "./index";
+import AccountLendingPool from "./AccountLendingPool";
+import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+export default class Account {
+    router: ImpermaxRouter;
+    account: Address;
+    accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
+    cache: {
+        airdropData: {
+            [key in string]?: Promise<AirdropData>;
+        };
+        claimableIBEX?: {
+            [key in Address]?: Promise<number>;
+        };
+    };
+    constructor(router: ImpermaxRouter, account: Address);
+    cleanCache(): Promise<void>;
+    private initializeAccountLendingPool;
+    getAccountLendingPool(factory: Factory, pair: Address): Promise<AccountLendingPool>;
+    getMassAvailableReward(pairs: FactoryIndex<Address[]>): Promise<LendingPoolIndex<PendingRewardUI[]>>;
+    private initializeAirdropData;
+    private getAirdropData;
+    getIbexAirdropData(): Promise<AirdropData>;
+    getIbex2AirdropData(): Promise<AirdropData>;
+    getEthAirdropData(): Promise<AirdropData>;
+    hasIbexClaimableAirdrop(): Promise<boolean>;
+    hasEthClaimableAirdrop(): Promise<boolean>;
+    initializeClaimableIBEX(claimableAddress: Address): Promise<number>;
+    getClaimableIBEX(claimableAddress: Address): Promise<number>;
+}

package/lib/impermax-router/Account.js

@@ -0,0 +1,154 @@
+"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 ethers_1 = require("ethers");
+const merkle_distributors_1 = require("../config/endpoints/merkle-distributors");
+class Account {
+    constructor(router, account) {
+        this.cache = { airdropData: {} };
+        this.router = router;
+        this.account = account;
+        this.accountLLPs = {};
+        this.cache.claimableIBEX = {};
+    }
+    cleanCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cache = { airdropData: {} };
+            this.cache.claimableIBEX = {};
+            for (const factory of Object.keys(this.accountLLPs)) {
+                for (const pairAddress of Object.keys(this.accountLLPs[factory])) {
+                    (yield this.accountLLPs[factory][pairAddress]).cleanCache();
+                }
+            }
+        });
+    }
+    initializeAccountLendingPool(factory, pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.router.getFactory(factory).getLendingPool(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];
+        });
+    }
+    // Mass Available Reward (only supports ImpermaxChef)
+    getMassAvailableReward(pairs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            if (!pairs)
+                return result;
+            const requests = [];
+            const factories = Object.keys(pairs);
+            for (const factory of factories) {
+                const requestsLocal = [];
+                for (const pairAddress of pairs[factory]) {
+                    requestsLocal.push((yield this.getAccountLendingPool(factory, pairAddress)).getAvailableReward());
+                }
+                requests.push(Promise.all(requestsLocal));
+            }
+            const data = yield Promise.all(requests);
+            for (let i = 0; i < factories.length; i++) {
+                const factory = factories[i];
+                result[factory] = {};
+                for (let j = 0; j < pairs[factory].length; j++) {
+                    result[factory][pairs[factory][j]] = data[i][j];
+                }
+            }
+            return result;
+        });
+    }
+    // Airdrop Data
+    initializeAirdropData(airdropURL, merkleDistributor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (airdropURL && airdropURL !== '') {
+                try {
+                    const json = yield fetch(airdropURL + '/' + this.account);
+                    const data = yield json.json();
+                    if (data) {
+                        data.amount = ethers_1.BigNumber.from(data.amount);
+                        const isClaimed = yield merkleDistributor.methods.isClaimed(data.index).call();
+                        if (!isClaimed)
+                            return data;
+                    }
+                }
+                catch (e) { }
+            }
+            return {
+                index: -1,
+                amount: null,
+                proof: [],
+            };
+        });
+    }
+    getAirdropData(airdropURL, merkleDistributor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.airdropData[airdropURL])
+                this.cache.airdropData[airdropURL] = this.initializeAirdropData(airdropURL, merkleDistributor);
+            return this.cache.airdropData[airdropURL];
+        });
+    }
+    getIbexAirdropData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getAirdropData(merkle_distributors_1.MERKLE_URL_IBEX[this.router.network], this.router.contractsHelper.merkleDistributorIbex);
+        });
+    }
+    getIbex2AirdropData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getAirdropData(merkle_distributors_1.MERKLE_URL_IBEX_2[this.router.network], this.router.contractsHelper.merkleDistributorIbex2);
+        });
+    }
+    getEthAirdropData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getAirdropData(merkle_distributors_1.MERKLE_URL_ETH[this.router.network], this.router.contractsHelper.merkleDistributorEth);
+        });
+    }
+    hasIbexClaimableAirdrop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const airdropData = yield this.getIbexAirdropData();
+            if (airdropData.amount)
+                return true;
+            return false;
+        });
+    }
+    hasEthClaimableAirdrop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const airdropData = yield this.getEthAirdropData();
+            if (airdropData.amount)
+                return true;
+            return false;
+        });
+    }
+    // Claim Claimable IBEX
+    initializeClaimableIBEX(claimableAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimable = this.router.contractsHelper.newClaimable(claimableAddress);
+            return (yield claimable.methods.claim().call({ from: this.account })) / 1e18;
+        });
+    }
+    getClaimableIBEX(claimableAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.claimableIBEX[claimableAddress])
+                this.cache.claimableIBEX[claimableAddress] = this.initializeClaimableIBEX(claimableAddress);
+            return this.cache.claimableIBEX[claimableAddress];
+        });
+    }
+}
+exports.default = Account;

package/lib/impermax-router/AccountBorrowable.d.ts

@@ -0,0 +1,22 @@
+import AccountPoolToken from "./AccountPoolToken";
+import Borrowable from "./Borrowable";
+export default class AccountBorrowable extends AccountPoolToken {
+    poolToken: Borrowable;
+    borrowableCache: {
+        borrowed?: Promise<number>;
+        farmingShares?: Promise<number>;
+        availableIMXReward?: Promise<number>;
+        availableRewarderReward?: Promise<number>;
+    };
+    cleanCache(): void;
+    private initializeBorrowed;
+    getBorrowed(): Promise<number>;
+    getBorrowedUSD(): Promise<number>;
+    getMaxBorrowable(): Promise<number>;
+    private initializeFarmingShares;
+    getFarmingShares(): Promise<number>;
+    private initializeAvailableIMXReward;
+    getAvailableIMXReward(): Promise<number>;
+    private initializeAvailableRewarderReward;
+    getAvailableRewarderReward(): Promise<number>;
+}

package/lib/impermax-router/AccountBorrowable.js

@@ -0,0 +1,141 @@
+"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 types_1 = require("./types");
+const AccountPoolToken_1 = __importDefault(require("./AccountPoolToken"));
+const types_2 = require("../config/types");
+class AccountBorrowable extends AccountPoolToken_1.default {
+    constructor() {
+        super(...arguments);
+        this.borrowableCache = {};
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.borrowableCache = {};
+    }
+    // Borrowed
+    initializeBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowable = yield this.poolToken.getPoolToken();
+            const balance = yield borrowable.methods.borrowBalance(this.getAccount()).call();
+            const storedAmount = yield yield this.poolToken.normalize(balance);
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const borrowRate = yield this.getBorrowRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
+        });
+    }
+    getBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.borrowed)
+                this.borrowableCache.borrowed = this.initializeBorrowed();
+            return this.borrowableCache.borrowed;
+        });
+    }
+    getBorrowedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowed = yield this.getBorrowed();
+            const tokenPrice = yield this.getTokenPriceAccurate();
+            return borrowed * tokenPrice;
+        });
+    }
+    // Max Borrowable
+    getMaxBorrowable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableCash = yield this.poolToken.getTotalBalance();
+            const { valueCollateral, valueA, valueB } = yield this.accountLendingPool.getValues(types_1.NO_CHANGES);
+            const [valueBorrowed, valueOther] = this.poolToken.poolTokenType == types_2.PoolTokenType.BorrowableA ? [valueA, valueB] : [valueB, valueA];
+            const safetyMargin = (yield this.accountLendingPool.getSafetyMargin()) * this.getUiMargin();
+            const liquidationPenalty = yield this.accountLendingPool.getLiquidationPenalty();
+            const actualCollateral = valueCollateral / liquidationPenalty;
+            const totalValueBorrowable1 = (actualCollateral * Math.sqrt(safetyMargin) - valueOther) / safetyMargin;
+            const totalValueBorrowable2 = (actualCollateral / Math.sqrt(safetyMargin) - valueOther) * safetyMargin;
+            const maxValueBorrowable = Math.min(totalValueBorrowable1, totalValueBorrowable2) - valueBorrowed;
+            const price = yield this.poolToken.getMarketPriceDenomLP();
+            return Math.max(0, Math.min(availableCash, maxValueBorrowable / price));
+        });
+    }
+    // Farming Shares
+    initializeFarmingShares() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.poolToken.hasFarming()))
+                return 0;
+            if (yield this.poolToken.hasImpermaxChef()) {
+                const c = (yield this.poolToken.getImpermaxChef().methods.userInfo(yield this.poolToken.getPoolTokenAddress(), this.getAccount()).call()).shares;
+                return c;
+            }
+            else {
+                const farmingPool = yield this.poolToken.getFarmingPool();
+                return (yield farmingPool.methods.recipients(this.getAccount()).call()).shares;
+            }
+        });
+    }
+    getFarmingShares() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.farmingShares)
+                this.borrowableCache.farmingShares = this.initializeFarmingShares();
+            return this.borrowableCache.farmingShares;
+        });
+    }
+    // Available Reward
+    initializeAvailableIMXReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.poolToken.hasFarming()))
+                return 0;
+            if (yield this.poolToken.hasImpermaxChef()) {
+                const borrowableAddress = yield this.poolToken.getPoolTokenAddress();
+                try {
+                    return (yield this.poolToken.getImpermaxChef().methods.pendingReward(borrowableAddress, this.getAccount()).call()) / 1e18;
+                }
+                catch (_a) {
+                    console.log("Warning: pending reward negative");
+                    return 0;
+                }
+            }
+            else {
+                const farmingPool = yield this.poolToken.getFarmingPool();
+                return (yield farmingPool.methods.claim().call({ from: this.getAccount() })) / 1e18;
+            }
+        });
+    }
+    getAvailableIMXReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.availableIMXReward)
+                this.borrowableCache.availableIMXReward = this.initializeAvailableIMXReward();
+            return this.borrowableCache.availableIMXReward;
+        });
+    }
+    initializeAvailableRewarderReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.poolToken.hasRewarder()))
+                return 0;
+            const borrowableAddress = yield this.poolToken.getPoolTokenAddress();
+            const rewarder = yield this.poolToken.getRewarder();
+            try {
+                return (yield rewarder.methods.pendingReward(borrowableAddress, this.getAccount()).call()) / 1e18;
+            }
+            catch (_a) {
+                console.log("Warning: pending reward negative");
+                return 0;
+            }
+        });
+    }
+    getAvailableRewarderReward() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.borrowableCache.availableRewarderReward)
+                this.borrowableCache.availableRewarderReward = this.initializeAvailableRewarderReward();
+            return this.borrowableCache.availableRewarderReward;
+        });
+    }
+}
+exports.default = AccountBorrowable;

package/lib/impermax-router/AccountCollateral.d.ts

@@ -0,0 +1,11 @@
+import AccountPoolToken from "./AccountPoolToken";
+import Collateral from "./Collateral";
+export default class AccountCollateral extends AccountPoolToken {
+    poolToken: Collateral;
+    collateralCache: {};
+    cleanCache(): void;
+    fixStakedLPExchangeRate(n: Promise<number>): Promise<number>;
+    getAvailableBalanceUSD(): Promise<number>;
+    getDepositedUSD(): Promise<number>;
+    getMaxWithdrawable(): Promise<number>;
+}