impermax-sdk 1.2.69 → 1.2.71

package/lib/offchain/account/lendingPool/borrowable.d.ts

@@ -0,0 +1,14 @@
+import { PoolTokenType } from '../../../config/types';
+import LendingPool from './index';
+import PoolToken from '../poolToken';
+import * as offchain from '../../index';
+export default class Borrowable extends PoolToken {
+    accountLendingPool: LendingPool;
+    poolToken: offchain.lendingPool.Borrowable;
+    constructor(accountLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    private getSupplyPosition;
+    getAmount(): Promise<number>;
+    private getBorrowPosition;
+    getBorrowedAmount(): Promise<number>;
+    getBorrowedValue(): Promise<number>;
+}

package/lib/offchain/account/lendingPool/borrowable.js

@@ -0,0 +1,73 @@
+"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 poolToken_1 = __importDefault(require("../poolToken"));
+class Borrowable extends poolToken_1.default {
+    constructor(accountLendingPool, poolTokenType) {
+        super();
+        this.accountLendingPool = accountLendingPool;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    getSupplyPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.lendingPool.getUserData();
+            if (!userData)
+                return undefined;
+            const supplyPositions = userData.supplyPositions[this.offchainPoolToken.lendingPool.pairAddress];
+            if (!supplyPositions)
+                return undefined;
+            return supplyPositions[this.offchainPoolToken.poolTokenType];
+        });
+    }
+    getAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyPosition = yield this.getSupplyPosition();
+            if (!supplyPosition)
+                return 0;
+            const exchangeRate = yield this.offchainPoolToken.getExchangeRate();
+            const supplyBalance = parseFloat(supplyPosition.balance);
+            return supplyBalance * exchangeRate;
+        });
+    }
+    getBorrowPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.lendingPool.getUserData();
+            if (!userData)
+                return undefined;
+            const borrowPositions = userData.borrowPositions[this.offchainPoolToken.lendingPool.pairAddress];
+            if (!borrowPositions)
+                return undefined;
+            return borrowPositions[this.offchainPoolToken.poolTokenType];
+        });
+    }
+    getBorrowedAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowPosition = yield this.getBorrowPosition();
+            const borrowIndex = yield this.offchainPoolToken.getBorrowIndex();
+            if (!borrowPosition)
+                return 0;
+            const borrowBalance = parseFloat(borrowPosition.borrowBalance);
+            const userBorrowIndex = parseFloat(borrowPosition.borrowIndex);
+            return borrowBalance * borrowIndex / userBorrowIndex;
+        });
+    }
+    getBorrowedValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenPrice = yield this.offchainPoolToken.getTokenPriceAccurate();
+            const borrowedAmount = yield this.getBorrowedAmount();
+            return borrowedAmount * tokenPrice;
+        });
+    }
+}
+exports.default = Borrowable;

package/lib/offchain/account/lendingPool/collateral.d.ts

@@ -0,0 +1,12 @@
+import { CollateralPosition } from "../../types";
+import { PoolTokenType } from '../../../config/types';
+import LendingPool from './index';
+import PoolToken from '../poolToken';
+import * as offchain from '../../index';
+export default class Collateral extends PoolToken {
+    accountLendingPool: LendingPool;
+    poolToken: offchain.lendingPool.Collateral;
+    constructor(accountLendingPool: LendingPool, poolTokenType: PoolTokenType);
+    getCollateralPosition(): Promise<CollateralPosition | undefined>;
+    getAmount(): Promise<number>;
+}

package/lib/offchain/account/lendingPool/collateral.js

@@ -0,0 +1,42 @@
+"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("../../../config/types");
+const poolToken_1 = __importDefault(require("../poolToken"));
+class Collateral extends poolToken_1.default {
+    constructor(accountLendingPool, poolTokenType) {
+        super();
+        this.accountLendingPool = accountLendingPool;
+        this.poolToken = accountLendingPool.lendingPool.poolTokens[poolTokenType];
+    }
+    getCollateralPosition() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userData = yield this.lendingPool.getUserData();
+            if (!userData)
+                return undefined;
+            return userData.collateralPositions[this.offchainPoolToken.lendingPool.pairAddress];
+        });
+    }
+    getAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralPosition = yield this.getCollateralPosition();
+            if (!collateralPosition)
+                return 0;
+            const exchangeRate = yield this.offchainPoolToken.lendingPool.poolTokens[types_1.PoolTokenType.Collateral].getExchangeRate();
+            const collateralBalance = parseFloat(collateralPosition.balance);
+            return collateralBalance * exchangeRate;
+        });
+    }
+}
+exports.default = Collateral;

package/lib/offchain/account/lendingVault.d.ts

@@ -0,0 +1,11 @@
+import * as offchain from '../index';
+import Account from './index';
+import PoolToken from './poolToken';
+export default class LendingVault extends PoolToken {
+    account: Account;
+    poolToken: offchain.LendingVault;
+    constructor(account: Account, lendingVault: offchain.LendingVault);
+    getAmount(): Promise<number>;
+    getEarnings(): Promise<number>;
+    getEarningsUSD(): Promise<number>;
+}

package/lib/offchain/account/lendingVault.js

@@ -0,0 +1,38 @@
+"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 poolToken_1 = __importDefault(require("./poolToken"));
+class LendingVault extends poolToken_1.default {
+    constructor(account, lendingVault) {
+        super();
+        this.account = account;
+        this.poolToken = lendingVault;
+    }
+    getAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getEarnings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getEarningsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = LendingVault;

package/lib/offchain/account/poolToken.d.ts

@@ -0,0 +1,6 @@
+import * as offchain from "../";
+export default abstract class PoolToken {
+    poolToken: offchain.PoolToken;
+    abstract getAmount(): Promise<number>;
+    getValue(): Promise<number>;
+}

package/lib/offchain/account/poolToken.js

@@ -0,0 +1,21 @@
+"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 });
+class PoolToken {
+    getValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenPrice = yield this.offchainPoolToken.getTokenPriceAccurate();
+            const amount = yield this.getAmount();
+            return amount * tokenPrice;
+        });
+    }
+}
+exports.default = PoolToken;

package/lib/offchain/initializer.d.ts

@@ -0,0 +1,32 @@
+import { ApolloQueryResult } from "apollo-client";
+import Offchain from "./index";
+import { DocumentNode } from "graphql";
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import { Amms } from '../config/amms';
+import { LendingPoolData, RawUserData, TvlData, UserData, XimxData } from './types';
+export declare function apolloFetcher(subgraphUrl: string, query: DocumentNode): Promise<ApolloQueryResult<any>>;
+export declare function fetchBlockByTimestamp(this: Offchain, timestamp: number): Promise<number | null>;
+export declare function fetchLendingPools(this: Offchain): Promise<FactoryIndex<LendingPoolData[]>>;
+export declare function fetchLendingPoolsPast(this: Offchain, seconds: number): Promise<FactoryIndex<any[]> | null>;
+export declare function fetchImpermaxChefRewardRates(this: Offchain): Promise<AddressIndex<Array<{
+    rewardToken: Address;
+    rewardRate: number;
+}>> | null>;
+export declare function fetchPastVolume(this: Offchain, amm: Amms, lendingPools: LendingPoolData[], seconds: number): Promise<AddressIndex<number>>;
+export declare function fetchCurrentVolumeAndReserves(this: Offchain, amm: Amms, lendingPools: LendingPoolData[]): Promise<{
+    currentVolume: AddressIndex<number>;
+    currentReserve: AddressIndex<number>;
+}>;
+export declare function fetchUniswapAPR(this: Offchain, lendingPoolsByAmm: {
+    [key in Amms]?: LendingPoolData[];
+}, seconds?: number): Promise<AddressIndex<number>>;
+export declare function initializeLendingPoolsData(this: Offchain): Promise<LendingPoolIndex<LendingPoolData>>;
+export declare function getLendingPoolsData(this: Offchain): Promise<LendingPoolIndex<LendingPoolData>>;
+export declare function getLendingPoolData(this: Offchain, factory: Factory, uniswapV2PairAddress: Address): Promise<LendingPoolData>;
+export declare function initializeTvlData(this: Offchain): Promise<TvlData>;
+export declare function getTvlData(this: Offchain): Promise<TvlData>;
+export declare function fetchUserData(this: Offchain, account: Address): Promise<FactoryIndex<RawUserData>>;
+export declare function initializeUserData(this: Offchain, account: Address): Promise<FactoryIndex<UserData> | null>;
+export declare function getUserData(this: Offchain, account: Address): Promise<FactoryIndex<UserData> | null>;
+export declare function initializeXimxData(this: Offchain): Promise<XimxData>;
+export declare function getXimxData(this: Offchain): Promise<XimxData>;