impermax-sdk 1.2.112 → 2.0.0

package/lib/onchain/onchainLendingVault.js

@@ -1,69 +1,69 @@
-"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 onchainPoolToken_1 = __importDefault(require("./onchainPoolToken"));
-const lending_vault_watcher_1 = require("../config/contracts/lending-vault-watcher");
-class OnchainLendingVault extends onchainPoolToken_1.default {
-    constructor(onchain, vaultAddress) {
-        super();
-        this.lendingVaultCache = {};
-        this.getOnchain = () => this.onchain;
-        this.getVaultAddress = () => this.vaultAddress;
-        this.getContractHelper = () => this.onchain.getContractHelper();
-        this.getOffchainLendingVault = this.getOffchainPoolToken;
-        this.onchain = onchain;
-        this.vaultAddress = vaultAddress;
-    }
-    cleanCache() {
-        this.cache = {};
-        this.lendingVaultCache = {};
-    }
-    getPoolTokenAddress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.vaultAddress;
-        });
-    }
-    getOffchainPoolToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.onchain.getOffchain().getLendingVault(this.vaultAddress);
-        });
-    }
-    initializePoolToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getContractHelper().newLendingVault(yield this.getPoolTokenAddress());
-        });
-    }
-    initializeToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const poolToken = yield this.getPoolToken();
-            return this.getContractHelper().newERC20(yield poolToken.methods.underlying().call());
-        });
-    }
-    // Available Liquidity
-    initializeAvailableLiquidity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const lendingVaultWatcher = this.onchain.getContractHelper().newLendingVaultWatcher(lending_vault_watcher_1.LENDING_VAULT_WATCHER[this.onchain.network]);
-            const amount = yield lendingVaultWatcher.methods.getAvailableLiquidity(this.vaultAddress).call();
-            return this.normalize(amount);
-        });
-    }
-    getAvailableLiquidity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.lendingVaultCache.availableLiquidity)
-                this.lendingVaultCache.availableLiquidity = this.initializeAvailableLiquidity();
-            return this.lendingVaultCache.availableLiquidity;
-        });
-    }
-}
-exports.default = OnchainLendingVault;
+"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 onchainPoolToken_1 = __importDefault(require("./onchainPoolToken"));
+const lending_vault_watcher_1 = require("../config/contracts/lending-vault-watcher");
+class OnchainLendingVault extends onchainPoolToken_1.default {
+    constructor(onchain, vaultAddress) {
+        super();
+        this.lendingVaultCache = {};
+        this.getOnchain = () => this.onchain;
+        this.getVaultAddress = () => this.vaultAddress;
+        this.getContractHelper = () => this.onchain.getContractHelper();
+        this.getOffchainLendingVault = this.getOffchainPoolToken;
+        this.onchain = onchain;
+        this.vaultAddress = vaultAddress;
+    }
+    cleanCache() {
+        this.cache = {};
+        this.lendingVaultCache = {};
+    }
+    getPoolTokenAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.vaultAddress;
+        });
+    }
+    getOffchainPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.onchain.getOffchain().getLendingVault(this.vaultAddress);
+        });
+    }
+    initializePoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getContractHelper().newLendingVault(yield this.getPoolTokenAddress());
+        });
+    }
+    initializeToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolToken = yield this.getPoolToken();
+            return this.getContractHelper().newERC20(yield poolToken.methods.underlying().call());
+        });
+    }
+    // Available Liquidity
+    initializeAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingVaultWatcher = this.onchain.getContractHelper().newLendingVaultWatcher(lending_vault_watcher_1.LENDING_VAULT_WATCHER[this.onchain.network]);
+            const amount = yield lendingVaultWatcher.methods.getAvailableLiquidity(this.vaultAddress).call();
+            return this.normalize(amount);
+        });
+    }
+    getAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.lendingVaultCache.availableLiquidity)
+                this.lendingVaultCache.availableLiquidity = this.initializeAvailableLiquidity();
+            return this.lendingVaultCache.availableLiquidity;
+        });
+    }
+}
+exports.default = OnchainLendingVault;

package/lib/onchain/onchainPermitHelper.d.ts

@@ -0,0 +1,21 @@
+import { Contract, Permit, Permits } from "./onchainTypes";
+import Onchain from "./index";
+import { Address } from '../config/types';
+import { BigNumber } from "ethers";
+export default class OnchainPermitHelper {
+    private readonly onchain;
+    private readonly permit2;
+    private readonly deadline;
+    constructor(onchain: Onchain);
+    encodePermits(permits: Permits): string;
+    private getDomainPermit1;
+    private getDomainPermit2;
+    private getTokenPermitJSONData;
+    private getBorrowPermitJSONData;
+    private getNftPermitJSONData;
+    private getPermit2SingleJSONData;
+    private getSignature;
+    getTokenPermit(token: Contract, owner: Address, spender: Address, value: BigNumber, callBack: (permit: Permit | null) => void): Promise<void>;
+    getNftPermit(token: Contract, owner: Address, spender: Address, tokenId: BigNumber, callBack: (permit: Permit | null) => void): Promise<void>;
+    getPermit2Single(token: Contract, owner: Address, spender: Address, value: BigNumber, callBack: (permit: Permit | null) => void): Promise<void>;
+}

package/lib/onchain/onchainPermitHelper.js

@@ -0,0 +1,198 @@
+"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 ethers_1 = require("ethers");
+const general_1 = require("../config/general");
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+const EIP712_DOMAIN = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+];
+const PERMIT2_DOMAIN = [
+    { name: "name", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+];
+const PERMIT = [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+];
+const NFT_PERMIT = [
+    { name: "spender", type: "address" },
+    { name: "tokenId", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+];
+const PERMIT2_DETAILS = [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint160" },
+    { name: "expiration", type: "uint48" },
+    { name: "nonce", type: "uint48" },
+];
+const PERMIT2_SINGLE = [
+    { name: "details", type: PERMIT2_DETAILS },
+    { name: "spender", type: "address" },
+    { name: "sigDeadline", type: "uint256" },
+];
+const TYPES = {
+    EIP712Domain: EIP712_DOMAIN,
+    Permit2Domain: PERMIT2_DOMAIN,
+    TokenPermit: PERMIT,
+    BorrowPermit: PERMIT,
+    NftPermit: NFT_PERMIT,
+    PermitDetails: PERMIT2_DETAILS,
+    PermitSingle: PERMIT2_SINGLE,
+};
+class OnchainPermitHelper {
+    // TODO crate new router for V2 otherwise borrowPermit will stop working
+    constructor(onchain) {
+        this.deadline = general_1.DEADLINE.toString();
+        this.getDomainPermit1 = (contract) => __awaiter(this, void 0, void 0, function* () {
+            return ({
+                name: yield contract.methods.name().call(),
+                version: "1",
+                chainId: this.onchain.chainId,
+                verifyingContract: contract._address,
+            });
+        });
+        this.getDomainPermit2 = () => ({
+            name: 'Permit2',
+            chainId: this.onchain.chainId,
+            verifyingContract: this.permit2._address,
+        });
+        this.onchain = onchain;
+        this.permit2 = onchain.getContractHelper().newPermit2(PERMIT2_ADDRESS);
+    }
+    encodePermits(permits) {
+        if (permits.length == 0 || !permits[0].signature)
+            permits = [];
+        return ethers_1.ethers.utils.defaultAbiCoder.encode(['tuple(uint256 permitType, bytes permitData, bytes signature)[]'], [permits]);
+    }
+    getTokenPermitJSONData(contract, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const domain = yield this.getDomainPermit1(contract);
+            const primaryType = "TokenPermit";
+            return JSON.stringify({ types: TYPES, domain, primaryType, message });
+        });
+    }
+    getBorrowPermitJSONData(contract, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const domain = yield this.getDomainPermit1(contract);
+            const primaryType = "BorrowPermit";
+            return JSON.stringify({ types: TYPES, domain, primaryType, message });
+        });
+    }
+    getNftPermitJSONData(contract, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const domain = yield this.getDomainPermit1(contract);
+            const primaryType = "NftPermit";
+            return JSON.stringify({ types: TYPES, domain, primaryType, message });
+        });
+    }
+    getPermit2SingleJSONData(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const domain = this.getDomainPermit2();
+            const primaryType = "PermitSingle";
+            return JSON.stringify({ types: TYPES, domain, primaryType, message });
+        });
+    }
+    getSignature(owner, jsonData, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.onchain.web3.currentProvider.send({
+                method: "eth_signTypedData_v4",
+                params: [owner, jsonData],
+                from: owner
+            }, (err, data) => {
+                if (err) {
+                    console.error(err);
+                    return callBack(null);
+                }
+                callBack(data.result);
+            });
+        });
+    }
+    getTokenPermit(token, owner, spender, value, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = yield token.methods.nonces(owner).call();
+            const jsonData = yield this.getTokenPermitJSONData(token, {
+                owner,
+                spender,
+                value: value.toString(),
+                nonce: ethers_1.BigNumber.from(nonce).toHexString(),
+                deadline: this.deadline,
+            });
+            this.getSignature(owner, jsonData, (signature) => {
+                if (!signature)
+                    return callBack(null);
+                callBack({
+                    permitType: '0',
+                    permitData: ethers_1.ethers.utils.defaultAbiCoder.encode(['address', 'uint256', 'uint256'], [token.address, value.toString(), this.deadline]),
+                    signature
+                });
+            });
+        });
+    }
+    getNftPermit(token, owner, spender, tokenId, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = yield token.methods.nonces(tokenId).call();
+            const jsonData = yield this.getNftPermitJSONData(token, {
+                spender,
+                tokenId: tokenId.toString(),
+                nonce: ethers_1.BigNumber.from(nonce).toHexString(),
+                deadline: this.deadline,
+            });
+            this.getSignature(owner, jsonData, (signature) => {
+                if (!signature)
+                    return callBack(null);
+                callBack({
+                    permitType: '1',
+                    permitData: ethers_1.ethers.utils.defaultAbiCoder.encode(['address', 'uint256', 'uint256'], [token.address, tokenId.toString(), this.deadline]),
+                    signature
+                });
+            });
+        });
+    }
+    getPermit2Single(token, owner, spender, value, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allowanceData = yield this.permit2.methods.allowance(owner, token.address, spender);
+            if (!allowanceData)
+                return callBack(null);
+            const nonce = allowanceData.nonce;
+            const permitDetailsType = 'tuple(address tokenAddress, uint160 amount, uint48 expiration, uint48 nonce)';
+            const details = {
+                token: token._address,
+                amount: value.toString(),
+                expiration: this.deadline,
+                nonce: ethers_1.BigNumber.from(nonce).toHexString(),
+            };
+            const jsonData = yield this.getPermit2SingleJSONData({
+                details,
+                spender,
+                sigDeadline: this.deadline,
+            });
+            this.getSignature(owner, jsonData, (signature) => {
+                if (!signature)
+                    return callBack(null);
+                callBack({
+                    permitType: '2',
+                    permitData: ethers_1.ethers.utils.defaultAbiCoder.encode([permitDetailsType, 'address', 'uint256'], [token, spender, this.deadline]),
+                    signature
+                });
+            });
+        });
+    }
+}
+exports.default = OnchainPermitHelper;

package/lib/onchain/onchainPoolToken.d.ts

@@ -1,35 +1,35 @@
-import { BigNumber } from "ethers";
-import { Contract } from "./onchainTypes";
-import { Address } from '../config/types';
-import OffchainPoolToken from '../offchain/offchainPoolToken';
-export default abstract class OnchainPoolToken {
-    protected cache: {
-        token?: Promise<Contract>;
-        poolToken?: Promise<Contract>;
-        exchangeRate?: Promise<number>;
-        totalBalance?: Promise<number>;
-    };
-    protected lockedCache: {
-        exchangeRate?: Promise<number>;
-    };
-    cleanCache(): void;
-    abstract getOffchainPoolToken(): Promise<OffchainPoolToken>;
-    abstract getPoolTokenAddress(): Promise<Address>;
-    protected abstract initializePoolToken(): Promise<Contract>;
-    getPoolToken(): Promise<any>;
-    protected abstract initializeToken(): Promise<Contract>;
-    getToken(): Promise<any>;
-    getTokenAddress(): Promise<any>;
-    getDecimals(): Promise<number>;
-    normalize(amount: number): Promise<number>;
-    toBigNumber(amount: number): Promise<BigNumber | null>;
-    toNumber(amount: BigNumber): Promise<number | null>;
-    toTokens(amount: number): Promise<BigNumber | null>;
-    fromTokens(amount: BigNumber): Promise<number | null>;
-    private initializeTotalBalance;
-    getTotalBalance(): Promise<number>;
-    getTotalBalanceUSD(): Promise<number>;
-    protected initializeExchangeRate(): Promise<number>;
-    getExchangeRate(): Promise<number>;
-    getLockedExchangeRate(): Promise<number>;
-}
+import { BigNumber } from "ethers";
+import { Contract } from "./onchainTypes";
+import { Address } from '../config/types';
+import OffchainPoolToken from '../offchain/offchainPoolToken';
+export default abstract class OnchainPoolToken {
+    protected cache: {
+        token?: Promise<Contract>;
+        poolToken?: Promise<Contract>;
+        exchangeRate?: Promise<number>;
+        totalBalance?: Promise<number>;
+    };
+    protected lockedCache: {
+        exchangeRate?: Promise<number>;
+    };
+    cleanCache(): void;
+    abstract getOffchainPoolToken(): Promise<OffchainPoolToken>;
+    abstract getPoolTokenAddress(): Promise<Address>;
+    protected abstract initializePoolToken(): Promise<Contract>;
+    getPoolToken(): Promise<any>;
+    protected abstract initializeToken(): Promise<Contract>;
+    getToken(): Promise<any>;
+    getTokenAddress(): Promise<any>;
+    getDecimals(): Promise<number>;
+    normalize(amount: number): Promise<number>;
+    toBigNumber(amount: number): Promise<BigNumber | null>;
+    toNumber(amount: BigNumber): Promise<number | null>;
+    toTokens(amount: number): Promise<BigNumber | null>;
+    fromTokens(amount: BigNumber): Promise<number | null>;
+    private initializeTotalBalance;
+    getTotalBalance(): Promise<number>;
+    getTotalBalanceUSD(): Promise<number>;
+    protected initializeExchangeRate(): Promise<number>;
+    getExchangeRate(): Promise<number>;
+    getLockedExchangeRate(): Promise<number>;
+}