@across-protocol/sdk 3.0.0

package/dist/cjs/pool/TransactionManager.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+function makeKey(tx) {
+    return JSON.stringify(Object.entries(tx).map(function (_a) {
+        var key = _a[0], value = _a[1];
+        return [key, (value || "").toString()];
+    }));
+}
+exports.default = (function (config, signer, emit) {
+    if (emit === void 0) { emit = function () { return null; }; }
+    (0, assert_1.default)(signer.provider, "signer requires a provider, use signer.connect(provider)");
+    var _a = config.confirmations, confirmations = _a === void 0 ? 3 : _a;
+    var requests = new Map();
+    var submissions = new Map();
+    var mined = new Map();
+    function request(unsignedTx) {
+        var populated = unsignedTx;
+        var key = makeKey(populated);
+        (0, assert_1.default)(!requests.has(key), "Transaction already in progress");
+        requests.set(key, populated);
+        return key;
+    }
+    function processRequest(key) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var request, sent, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        request = requests.get(key);
+                        (0, assert_1.default)(request, "invalid request");
+                        requests.delete(key);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4, signer.sendTransaction(request)];
+                    case 2:
+                        sent = _a.sent();
+                        submissions.set(key, sent.hash);
+                        emit("submitted", key, sent.hash);
+                        return [3, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        emit("error", key, err_1);
+                        return [3, 4];
+                    case 4: return [2];
+                }
+            });
+        });
+    }
+    function processSubmission(key) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hash, receipt;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hash = submissions.get(key);
+                        (0, assert_1.default)(hash, "invalid submission");
+                        (0, assert_1.default)(signer.provider, "signer requires a provider, use signer.connect(provider)");
+                        return [4, signer.provider.getTransactionReceipt(hash).catch(function () { return undefined; })];
+                    case 1:
+                        receipt = _a.sent();
+                        if (receipt == null)
+                            return [2];
+                        if (receipt.confirmations < confirmations)
+                            return [2];
+                        submissions.delete(key);
+                        mined.set(key, receipt);
+                        emit("mined", key, receipt);
+                        return [2];
+                }
+            });
+        });
+    }
+    function isMined(key) {
+        return mined.get(key);
+    }
+    function update() {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _i, _a, key, _b, _c, key;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _i = 0, _a = Object.keys(requests);
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3, 4];
+                        key = _a[_i];
+                        return [4, processRequest(key)];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _i++;
+                        return [3, 1];
+                    case 4:
+                        _b = 0, _c = Object.keys(submissions);
+                        _d.label = 5;
+                    case 5:
+                        if (!(_b < _c.length)) return [3, 8];
+                        key = _c[_b];
+                        return [4, processSubmission(key)];
+                    case 6:
+                        _d.sent();
+                        _d.label = 7;
+                    case 7:
+                        _b++;
+                        return [3, 5];
+                    case 8: return [2];
+                }
+            });
+        });
+    }
+    return {
+        request: request,
+        isMined: isMined,
+        update: update,
+    };
+});
+//# sourceMappingURL=TransactionManager.js.map

package/dist/cjs/pool/TransactionManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionManager.js","sourceRoot":"","sources":["../../../src/pool/TransactionManager.ts"],"names":[],"mappings":"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"}

package/dist/cjs/pool/index.d.ts

@@ -0,0 +1 @@
+export * from "./poolClient";

package/dist/cjs/pool/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./poolClient"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/pool/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/pool/index.ts"],"names":[],"mappings":";;;AAAA,uDAA6B"}

package/dist/cjs/pool/poolClient.d.ts

@@ -0,0 +1,232 @@
+import * as uma from "@uma/sdk";
+import { BigNumberish } from "../utils";
+import { Signer, BigNumber } from "ethers";
+import type { Overrides } from "@ethersproject/contracts";
+import { TransactionRequest, TransactionReceipt, Log } from "@ethersproject/abstract-provider";
+import { Provider, Block } from "@ethersproject/providers";
+import { hubPool } from "../contracts";
+import { AcceleratingDistributor, MerkleDistributor } from "../typechain";
+export type { Provider };
+export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
+export type Config = {
+    chainId?: number;
+    hubPoolAddress: string;
+    acceleratingDistributorAddress: string;
+    merkleDistributorAddress: string;
+    wethAddress: string;
+    configStoreAddress: string;
+    confirmations?: number;
+    blockDelta?: number;
+    hasArchive?: boolean;
+    hubPoolStartBlock?: number;
+};
+export type Dependencies = {
+    provider: Provider;
+};
+export type StakeData = {
+    cumulativeBalance: BigNumber;
+    amountAirdropped: BigNumber;
+};
+export type Pool = {
+    address: string;
+    totalPoolSize: string;
+    l1Token: string;
+    lpToken: string;
+    liquidReserves: string;
+    exchangeRateCurrent: string;
+    exchangeRatePrevious: string;
+    estimatedApy: string;
+    estimatedApr: string;
+    blocksElapsed: number;
+    secondsElapsed: number;
+    utilizedReserves: string;
+    projectedApr: string;
+    liquidityUtilizationCurrent: string;
+};
+export type User = {
+    address: string;
+    poolAddress: string;
+    lpTokens: string;
+    positionValue: string;
+    totalDeposited: string;
+    feesEarned: string;
+};
+export type Transaction = {
+    id: string;
+    state: "requested" | "submitted" | "mined" | "error";
+    toAddress: string;
+    fromAddress: string;
+    type: "Add Liquidity" | "Remove Liquidity";
+    description: string;
+    request?: TransactionRequest;
+    hash?: string;
+    receipt?: TransactionReceipt;
+    error?: Error;
+};
+export type Token = {
+    decimals: string;
+    symbol: string;
+    name: string;
+};
+export type State = {
+    pools: Record<string, Pool>;
+    users: Record<string, Record<string, User>>;
+    transactions: Record<string, Transaction>;
+    error?: Error;
+};
+export type EmitState = (path: string[], data: Pool | User | Transaction | Error) => void;
+export type PooledToken = {
+    lpToken: string;
+    isEnabled: boolean;
+    lastLpFeeUpdate: number;
+    utilizedReserves: BigNumber;
+    liquidReserves: BigNumber;
+    undistributedLpFees: BigNumber;
+};
+type EventIdParams = {
+    blockNumber: number;
+    transactionIndex: number;
+    logIndex: number;
+};
+export declare class PoolEventState {
+    private contract;
+    private startBlock;
+    private seen;
+    private iface;
+    private events;
+    constructor(contract: hubPool.Instance, startBlock?: number);
+    private makeId;
+    hasEvent(params: EventIdParams): boolean;
+    private addEvent;
+    private filterSeen;
+    private processEvent;
+    private processEvents;
+    read(endBlock: number, l1TokenAddress?: string, userAddress?: string): Promise<hubPool.EventState>;
+    makeEventFromLog: (log: Log) => uma.SerializableEvent;
+    getL1TokenFromReceipt(receipt: TransactionReceipt): string;
+    readTxReceipt(receipt: TransactionReceipt): hubPool.EventState;
+}
+declare class UserState {
+    private contract;
+    private userAddress;
+    private startBlock;
+    private acceleratingDistributorContractAddress;
+    private seen;
+    private events;
+    constructor(contract: uma.clients.erc20.Instance, userAddress: string, startBlock?: number, acceleratingDistributorContractAddress?: string);
+    private makeId;
+    hasEvent(params: EventIdParams): boolean;
+    private addEvent;
+    private filterSeen;
+    readEvents(endBlock: number): Promise<uma.clients.erc20.Transfer[]>;
+    read(endBlock: number): Promise<{
+        transferEvents: import("@uma/contracts-frontend").TypedEventEthers<[string, string, uma.oracle.types.ethers.BigNumber] & {
+            from: string;
+            to: string;
+            value: uma.oracle.types.ethers.BigNumber;
+        }>[];
+        balanceTransferred: string;
+        address: string;
+        balanceOf: uma.oracle.types.ethers.BigNumber;
+    }>;
+}
+export declare function calculateRemoval(amountWei: BigNumber, percentWei: BigNumber): {
+    recieve: string;
+    remain: string;
+};
+export declare function previewRemoval(values: {
+    positionValue: BigNumberish;
+    feesEarned: BigNumberish;
+    totalDeposited: BigNumberish;
+}, percentFloat: number): {
+    position: {
+        recieve: string;
+        remain: string;
+    };
+    fees: {
+        recieve: string;
+        remain: string;
+    };
+    total: {
+        recieve: string;
+        remain: string;
+    };
+};
+export declare class ReadPoolClient {
+    private address;
+    private provider;
+    private poolState;
+    private contract;
+    constructor(address: string, provider: Provider);
+    read(tokenAddress: string, latestBlock: number): Promise<{
+        lpToken: string;
+        isEnabled: boolean;
+        lastLpFeeUpdate: number;
+        utilizedReserves: uma.oracle.types.ethers.BigNumber;
+        liquidReserves: uma.oracle.types.ethers.BigNumber;
+        undistributedLpFees: uma.oracle.types.ethers.BigNumber;
+        address: string;
+        l1Token: string;
+        latestBlock: number;
+        previousBlock: number | undefined;
+        exchangeRatePrevious: uma.oracle.types.ethers.BigNumber;
+        exchangeRateCurrent: uma.oracle.types.ethers.BigNumber;
+        liquidityUtilizationCurrent: uma.oracle.types.ethers.BigNumber;
+    }>;
+}
+export declare function validateWithdraw(pool: Pool, user: User, lpTokenAmount: BigNumberish): {
+    lpTokenAmount: uma.oracle.types.ethers.BigNumberish;
+    l1TokensToReturn: string;
+};
+export declare class Client {
+    readonly config: Config;
+    readonly deps: Dependencies;
+    private emit;
+    private transactionManagers;
+    private hubPool;
+    private acceleratingDistributor;
+    private merkleDistributor;
+    readonly state: State;
+    private poolEvents;
+    private erc20s;
+    private intervalStarted;
+    private configStoreClient;
+    private exchangeRateTable;
+    private userServices;
+    constructor(config: Config, deps: Dependencies, emit: EmitState);
+    getOrCreateErc20Contract(address: string): uma.clients.erc20.Instance;
+    getOrCreatePoolContract(): hubPool.Instance;
+    createHubPoolContract(signerOrProvider: Signer | Provider): hubPool.Instance;
+    private getOrCreatePoolEvents;
+    createAcceleratingDistributorContract(signerOrProvider: Signer | Provider): AcceleratingDistributor;
+    createMerkleDistributorContract(signerOrProvider: Signer | Provider): MerkleDistributor;
+    getOrCreateAcceleratingDistributorContract(): AcceleratingDistributor;
+    getOrCreateMerkleDistributorContract(): MerkleDistributor;
+    private getOrCreateUserService;
+    private updateExchangeRateTable;
+    resolveStakingData(lpToken: string, l1TokenAddress: string, userState: Awaited<ReturnType<UserState["read"]>>): Promise<StakeData>;
+    calculateLpTransferValue(l1TokenAddress: string, userState: Awaited<ReturnType<UserState["read"]>>): Promise<uma.oracle.types.ethers.BigNumber>;
+    private getOrCreateTransactionManager;
+    addEthLiquidity(signer: Signer, l1TokenAmount: BigNumberish, overrides?: Overrides): Promise<string>;
+    addTokenLiquidity(signer: Signer, l1Token: string, l1TokenAmount: BigNumberish, overrides?: Overrides): Promise<string>;
+    validateWithdraw(l1Token: string, userAddress: string, lpAmount: BigNumberish): Promise<{
+        lpTokenAmount: uma.oracle.types.ethers.BigNumberish;
+        l1TokensToReturn: string;
+    }>;
+    removeTokenLiquidity(signer: Signer, l1Token: string, lpTokenAmount: BigNumberish, overrides?: Overrides): Promise<string>;
+    removeEthliquidity(signer: Signer, lpTokenAmount: BigNumberish, overrides?: Overrides): Promise<string>;
+    getPoolState(l1TokenAddress: string): Pool;
+    hasPoolState(l1TokenAddress: string): boolean;
+    setUserState(l1TokenAddress: string, userAddress: string, state: User): User;
+    getUserState(l1TokenAddress: string, userAddress: string): User;
+    hasUserState(l1TokenAddress: string, userAddress: string): boolean;
+    hasTxState(id: string): boolean;
+    getTxState(id: string): Transaction;
+    private updateAndEmitUser;
+    private updateUserWithTransaction;
+    updateUser(userAddress: string, l1TokenAddress: string): Promise<void>;
+    updatePool(l1TokenAddress: string, overrideLatestBlock?: Block): Promise<void>;
+    updateTransactions(): Promise<void>;
+    startInterval(delayMs?: number): void;
+    stopInterval(): void;
+}