@across-protocol/sdk 3.0.0

package/dist/esm/clients/AcrossConfigStoreClient/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/clients/AcrossConfigStoreClient/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/esm/clients/BaseAbstractClient.d.ts

@@ -0,0 +1,51 @@
+import { providers } from "ethers";
+import { CachingMechanismInterface } from "../interfaces";
+import { EventSearchConfig, MakeOptional } from "../utils";
+export declare enum UpdateFailureReason {
+    AlreadyUpdated = 0,
+    BadRequest = 1,
+    RPCError = 2
+}
+export declare function isUpdateFailureReason(x: EventSearchConfig | UpdateFailureReason): x is UpdateFailureReason;
+/**
+ * Base class for all clients to extend.
+ */
+export declare abstract class BaseAbstractClient {
+    readonly eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock">;
+    protected cachingMechanism?: CachingMechanismInterface | undefined;
+    protected _isUpdated: boolean;
+    firstBlockToSearch: number;
+    latestBlockSearched: number;
+    /**
+     * Creates a new client.
+     * @param cachingMechanism The caching mechanism to use for this client. If not provided, the client will not rely on an external cache.
+     */
+    constructor(eventSearchConfig?: MakeOptional<EventSearchConfig, "toBlock">, cachingMechanism?: CachingMechanismInterface | undefined);
+    /**
+     * Indicates whether the client has been updated since it was created.
+     * @returns Whether the client has been updated since it was created.
+     */
+    get isUpdated(): boolean;
+    /**
+     * Sets whether the client has been updated since it was created.
+     * @param value Whether the client has been updated since it was created.
+     * @throws Error if the client has already been updated and the value is false.
+     */
+    set isUpdated(value: boolean);
+    /**
+     * Validates and updates the stored EventSearchConfig in advance of an update() call.
+     * Use isEventSearchConfig() to discriminate the result.
+     * @provider Ethers RPC provider instance.
+     * @returns An EventSearchConfig instance if valid, otherwise an UpdateFailureReason.
+     */
+    updateSearchConfig(provider: providers.Provider): Promise<EventSearchConfig | UpdateFailureReason>;
+    /**
+     * Asserts that the client has been updated.
+     */
+    protected assertUpdated(): void;
+    /**
+     * Determines if the client has an external cache.
+     * @returns Whether the client has an external cache.
+     */
+    protected hasCachingMechanism(): boolean;
+}

package/dist/esm/clients/BaseAbstractClient.js

@@ -0,0 +1,101 @@
+import { __awaiter, __generator } from "tslib";
+import { isDefined } from "../utils";
+export var UpdateFailureReason;
+(function (UpdateFailureReason) {
+    UpdateFailureReason[UpdateFailureReason["AlreadyUpdated"] = 0] = "AlreadyUpdated";
+    UpdateFailureReason[UpdateFailureReason["BadRequest"] = 1] = "BadRequest";
+    UpdateFailureReason[UpdateFailureReason["RPCError"] = 2] = "RPCError";
+})(UpdateFailureReason || (UpdateFailureReason = {}));
+export function isUpdateFailureReason(x) {
+    return Number.isInteger(x);
+}
+/**
+ * Base class for all clients to extend.
+ */
+var BaseAbstractClient = /** @class */ (function () {
+    /**
+     * Creates a new client.
+     * @param cachingMechanism The caching mechanism to use for this client. If not provided, the client will not rely on an external cache.
+     */
+    function BaseAbstractClient(eventSearchConfig, cachingMechanism) {
+        if (eventSearchConfig === void 0) { eventSearchConfig = { fromBlock: 0, maxBlockLookBack: 0 }; }
+        this.eventSearchConfig = eventSearchConfig;
+        this.cachingMechanism = cachingMechanism;
+        this.firstBlockToSearch = 0;
+        this.latestBlockSearched = 0;
+        this._isUpdated = false;
+    }
+    Object.defineProperty(BaseAbstractClient.prototype, "isUpdated", {
+        /**
+         * Indicates whether the client has been updated since it was created.
+         * @returns Whether the client has been updated since it was created.
+         */
+        get: function () {
+            return this._isUpdated;
+        },
+        /**
+         * Sets whether the client has been updated since it was created.
+         * @param value Whether the client has been updated since it was created.
+         * @throws Error if the client has already been updated and the value is false.
+         */
+        set: function (value) {
+            if (this._isUpdated === true && !value) {
+                throw new Error("Cannot set isUpdated to false once it is true");
+            }
+            this._isUpdated = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Validates and updates the stored EventSearchConfig in advance of an update() call.
+     * Use isEventSearchConfig() to discriminate the result.
+     * @provider Ethers RPC provider instance.
+     * @returns An EventSearchConfig instance if valid, otherwise an UpdateFailureReason.
+     */
+    BaseAbstractClient.prototype.updateSearchConfig = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fromBlock, toBlock, maxBlockLookBack;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fromBlock = this.firstBlockToSearch;
+                        toBlock = this.eventSearchConfig.toBlock;
+                        if (!isDefined(toBlock)) return [3 /*break*/, 1];
+                        if (fromBlock > toBlock) {
+                            throw new Error("Invalid event search config fromBlock (".concat(fromBlock, ") > toBlock (").concat(toBlock, ")"));
+                        }
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, provider.getBlockNumber()];
+                    case 2:
+                        toBlock = _a.sent();
+                        if (toBlock < fromBlock) {
+                            return [2 /*return*/, UpdateFailureReason.AlreadyUpdated];
+                        }
+                        _a.label = 3;
+                    case 3:
+                        maxBlockLookBack = this.eventSearchConfig.maxBlockLookBack;
+                        return [2 /*return*/, { fromBlock: fromBlock, toBlock: toBlock, maxBlockLookBack: maxBlockLookBack }];
+                }
+            });
+        });
+    };
+    /**
+     * Asserts that the client has been updated.
+     */
+    BaseAbstractClient.prototype.assertUpdated = function () {
+        if (!this.isUpdated) {
+            throw new Error("Client not updated");
+        }
+    };
+    /**
+     * Determines if the client has an external cache.
+     * @returns Whether the client has an external cache.
+     */
+    BaseAbstractClient.prototype.hasCachingMechanism = function () {
+        return isDefined(this.cachingMechanism);
+    };
+    return BaseAbstractClient;
+}());
+export { BaseAbstractClient };
+//# sourceMappingURL=BaseAbstractClient.js.map

package/dist/esm/clients/BaseAbstractClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseAbstractClient.js","sourceRoot":"","sources":["../../../src/clients/BaseAbstractClient.ts"],"names":[],"mappings":";AAEA,OAAO,EAAqB,SAAS,EAAgB,MAAM,UAAU,CAAC;AAEtE,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,iFAAc,CAAA;IACd,yEAAU,CAAA;IACV,qEAAQ,CAAA;AACV,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,UAAU,qBAAqB,CAAC,CAA0C;IAC9E,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH;IAKE;;;OAGG;IACH,4BACW,iBAAqG,EACpG,gBAA4C;QAD7C,kCAAA,EAAA,sBAAkE,SAAS,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE;QAArG,sBAAiB,GAAjB,iBAAiB,CAAoF;QACpG,qBAAgB,GAAhB,gBAAgB,CAA4B;QATjD,uBAAkB,GAAG,CAAC,CAAC;QACvB,wBAAmB,GAAG,CAAC,CAAC;QAU7B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAMD,sBAAW,yCAAS;QAJpB;;;WAGG;aACH;YACE,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;QAED;;;;WAIG;aACH,UAAqB,KAAc;YACjC,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE;gBACtC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;aAClE;YACD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAC1B,CAAC;;;OAZA;IAcD;;;;;OAKG;IACU,+CAAkB,GAA/B,UAAgC,QAA4B;;;;;;wBACpD,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC;wBACpC,OAAO,GAAK,IAAI,CAAC,iBAAiB,QAA3B,CAA4B;6BACrC,SAAS,CAAC,OAAO,CAAC,EAAlB,wBAAkB;wBACpB,IAAI,SAAS,GAAG,OAAO,EAAE;4BACvB,MAAM,IAAI,KAAK,CAAC,iDAA0C,SAAS,0BAAgB,OAAO,MAAG,CAAC,CAAC;yBAChG;;4BAES,qBAAM,QAAQ,CAAC,cAAc,EAAE,EAAA;;wBAAzC,OAAO,GAAG,SAA+B,CAAC;wBAC1C,IAAI,OAAO,GAAG,SAAS,EAAE;4BACvB,sBAAO,mBAAmB,CAAC,cAAc,EAAC;yBAC3C;;;wBAGK,gBAAgB,GAAK,IAAI,CAAC,iBAAiB,iBAA3B,CAA4B;wBACpD,sBAAO,EAAE,SAAS,WAAA,EAAE,OAAO,SAAA,EAAE,gBAAgB,kBAAA,EAAE,EAAC;;;;KACjD;IAED;;OAEG;IACO,0CAAa,GAAvB;QACE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;SACvC;IACH,CAAC;IAED;;;OAGG;IACO,gDAAmB,GAA7B;QACE,OAAO,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC1C,CAAC;IACH,yBAAC;AAAD,CAAC,AA5ED,IA4EC"}

package/dist/esm/clients/HubPoolClient.d.ts

@@ -0,0 +1,134 @@
+import { BigNumber, Contract, Event, EventFilter } from "ethers";
+import winston from "winston";
+import { CachingMechanismInterface, CancelledRootBundle, CrossChainContractsSet, Deposit, DepositWithBlock, DestinationTokenWithBlock, DisputedRootBundle, ExecutedRootBundle, L1Token, LpToken, PendingRootBundle, ProposedRootBundle, RealizedLpFee, TokenRunningBalance } from "../interfaces";
+import { BlockFinder, EventSearchConfig, MakeOptional } from "../utils";
+import { AcrossConfigStoreClient as ConfigStoreClient } from "./AcrossConfigStoreClient/AcrossConfigStoreClient";
+import { BaseAbstractClient, UpdateFailureReason } from "./BaseAbstractClient";
+type HubPoolUpdateSuccess = {
+    success: true;
+    currentTime: number;
+    pendingRootBundleProposal: PendingRootBundle;
+    events: Record<string, Event[]>;
+    searchEndBlock: number;
+};
+type HubPoolUpdateFailure = {
+    success: false;
+    reason: UpdateFailureReason;
+};
+export type HubPoolUpdate = HubPoolUpdateSuccess | HubPoolUpdateFailure;
+type HubPoolEvent = "SetPoolRebalanceRoute" | "L1TokenEnabledForLiquidityProvision" | "ProposeRootBundle" | "RootBundleCanceled" | "RootBundleDisputed" | "RootBundleExecuted" | "CrossChainContractsSet";
+type L1TokensToDestinationTokens = {
+    [l1Token: string]: {
+        [destinationChainId: number]: string;
+    };
+};
+export type LpFeeRequest = Pick<Deposit, "originChainId" | "inputToken" | "inputAmount" | "quoteTimestamp"> & {
+    paymentChainId?: number;
+};
+export declare class HubPoolClient extends BaseAbstractClient {
+    readonly logger: winston.Logger;
+    readonly hubPool: Contract;
+    configStoreClient: ConfigStoreClient;
+    deploymentBlock: number;
+    readonly chainId: number;
+    protected readonly configOverride: {
+        ignoredHubExecutedBundles: number[];
+        ignoredHubProposedBundles: number[];
+        timeToCache?: number;
+    };
+    protected l1TokensToDestinationTokens: L1TokensToDestinationTokens;
+    protected l1Tokens: L1Token[];
+    protected lpTokens: {
+        [token: string]: LpToken;
+    };
+    protected proposedRootBundles: ProposedRootBundle[];
+    protected canceledRootBundles: CancelledRootBundle[];
+    protected disputedRootBundles: DisputedRootBundle[];
+    protected executedRootBundles: ExecutedRootBundle[];
+    protected crossChainContracts: {
+        [l2ChainId: number]: CrossChainContractsSet[];
+    };
+    protected l1TokensToDestinationTokensWithBlock: {
+        [l1Token: string]: {
+            [destinationChainId: number]: DestinationTokenWithBlock[];
+        };
+    };
+    protected pendingRootBundle: PendingRootBundle | undefined;
+    currentTime: number | undefined;
+    readonly blockFinder: BlockFinder;
+    constructor(logger: winston.Logger, hubPool: Contract, configStoreClient: ConfigStoreClient, deploymentBlock?: number, chainId?: number, eventSearchConfig?: MakeOptional<EventSearchConfig, "toBlock">, configOverride?: {
+        ignoredHubExecutedBundles: number[];
+        ignoredHubProposedBundles: number[];
+        timeToCache?: number;
+    }, cachingMechanism?: CachingMechanismInterface);
+    protected hubPoolEventFilters(): Record<HubPoolEvent, EventFilter>;
+    hasPendingProposal(): boolean;
+    getPendingRootBundle(): PendingRootBundle | undefined;
+    getProposedRootBundles(): ProposedRootBundle[];
+    getCancelledRootBundles(): CancelledRootBundle[];
+    getDisputedRootBundles(): DisputedRootBundle[];
+    getExecutedRootBundles(): ExecutedRootBundle[];
+    getSpokePoolForBlock(chain: number, block?: number): string;
+    getSpokePoolActivationBlock(chain: number, spokePool: string): number | undefined;
+    getL2TokenForL1TokenAtBlock(l1Token: string, destinationChainId: number, latestHubBlock?: number): string;
+    getL1TokenForL2TokenAtBlock(l2Token: string, destinationChainId: number, latestHubBlock?: number): string;
+    /**
+     * Returns the L1 token that should be used for an L2 Bridge event. This function is
+     * designed to be used by the caller to associate the L2 token with its mapped L1 token
+     * at the HubPool equivalent block number of the L2 event.
+     * @param deposit Deposit event
+     * @param returns string L1 token counterpart for Deposit
+     */
+    getL1TokenForDeposit(deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">): string;
+    /**
+     * Returns the L2 token that should be used as a counterpart to a deposit event. For example, the caller
+     * might want to know what the refund token will be on l2ChainId for the deposit event.
+     * @param l2ChainId Chain where caller wants to get L2 token counterpart for
+     * @param event Deposit event
+     * @returns string L2 token counterpart on l2ChainId
+     */
+    getL2TokenForDeposit(deposit: Pick<DepositWithBlock, "originChainId" | "destinationChainId" | "inputToken" | "quoteBlockNumber">, l2ChainId?: number): string;
+    l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean;
+    getBlockNumber(timestamp: number): Promise<number | undefined>;
+    getCurrentPoolUtilization(l1Token: string): Promise<BigNumber>;
+    /**
+     * For a HubPool token at a specific block number, compute the relevant utilization.
+     * @param hubPoolToken HubPool token to query utilization for.
+     * @param blocknumber Block number to query utilization at.
+     * @param amount Amount to query. If set to 0, the closing utilization at blockNumber is returned.
+     * @param amount timestamp Associated quoteTimestamp for query, used for caching evaluation.
+     * @param timeToCache Age at which the response is able to be cached.
+     * @returns HubPool utilization at `blockNumber` after optional `amount` increase in utilization.
+     */
+    protected getUtilization(hubPoolToken: string, blockNumber: number, depositAmount: BigNumber, timestamp: number, timeToCache: number): Promise<BigNumber>;
+    computeRealizedLpFeePct(deposit: LpFeeRequest): Promise<RealizedLpFee>;
+    batchComputeRealizedLpFeePct(deposits: LpFeeRequest[]): Promise<RealizedLpFee[]>;
+    getL1Tokens(): L1Token[];
+    getTokenInfoForL1Token(l1Token: string): L1Token | undefined;
+    getLpTokenInfoForL1Token(l1Token: string): LpToken | undefined;
+    getL1TokenInfoForL2Token(l2Token: string, chainId: number): L1Token | undefined;
+    getTokenInfoForDeposit(deposit: Deposit): L1Token | undefined;
+    getTokenInfo(chainId: number | string, tokenAddress: string): L1Token | undefined;
+    areTokensEquivalent(tokenA: string, chainIdA: number, tokenB: string, chainIdB: number, hubPoolBlock?: number): boolean;
+    getSpokeActivationBlockForChain(chainId: number): number;
+    isRootBundleValid(rootBundle: ProposedRootBundle, latestMainnetBlock: number): boolean;
+    getRootBundleEvalBlockNumberContainingBlock(latestMainnetBlock: number, block: number, chain: number, chainIdListOverride?: number[]): number | undefined;
+    getProposedRootBundlesInBlockRange(startingBlock: number, endingBlock: number): ProposedRootBundle[];
+    getCancelledRootBundlesInBlockRange(startingBlock: number, endingBlock: number): CancelledRootBundle[];
+    getDisputedRootBundlesInBlockRange(startingBlock: number, endingBlock: number): DisputedRootBundle[];
+    getLatestProposedRootBundle(): ProposedRootBundle;
+    getFollowingRootBundle(currentRootBundle: ProposedRootBundle): ProposedRootBundle | undefined;
+    getExecutedLeavesForRootBundle(rootBundle: ProposedRootBundle, latestMainnetBlockToSearch: number): ExecutedRootBundle[];
+    getValidatedRootBundles(latestMainnetBlock?: number): ProposedRootBundle[];
+    getLatestFullyExecutedRootBundle(latestMainnetBlock: number): ProposedRootBundle | undefined;
+    getEarliestFullyExecutedRootBundle(latestMainnetBlock: number, startBlock?: number): ProposedRootBundle | undefined;
+    getNthFullyExecutedRootBundle(n: number, startBlock?: number): ProposedRootBundle | undefined;
+    getLatestBundleEndBlockForChain(chainIdList: number[], latestMainnetBlock: number, chainId: number): number;
+    getNextBundleStartBlockNumber(chainIdList: number[], latestMainnetBlock: number, chainId: number): number;
+    getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: string): TokenRunningBalance;
+    getRunningBalanceForToken(l1Token: string, executedRootBundle: ExecutedRootBundle): TokenRunningBalance;
+    _update(eventNames: HubPoolEvent[]): Promise<HubPoolUpdate>;
+    update(eventsToQuery?: HubPoolEvent[]): Promise<void>;
+    protected getBundleEndBlockForChain(proposeRootBundleEvent: ProposedRootBundle, chainId: number, chainIdList: number[]): number;
+}
+export {};