@lifi/sdk 1.1.4 → 1.1.5

package/dist/cjs/utils/multicallAbi.json

@@ -0,0 +1,313 @@
+[
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "address",
+                        "name": "target",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "callData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Call[]",
+                "name": "calls",
+                "type": "tuple[]"
+            }
+        ],
+        "name": "aggregate",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "blockNumber",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes[]",
+                "name": "returnData",
+                "type": "bytes[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "address",
+                        "name": "target",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "callData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Call[]",
+                "name": "calls",
+                "type": "tuple[]"
+            }
+        ],
+        "name": "blockAndAggregate",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "blockNumber",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "bool",
+                        "name": "success",
+                        "type": "bool"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "returnData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Result[]",
+                "name": "returnData",
+                "type": "tuple[]"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "blockNumber",
+                "type": "uint256"
+            }
+        ],
+        "name": "getBlockHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getBlockNumber",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "blockNumber",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getCurrentBlockCoinbase",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "coinbase",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getCurrentBlockDifficulty",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "difficulty",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getCurrentBlockGasLimit",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "gaslimit",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getCurrentBlockTimestamp",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "timestamp",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "addr",
+                "type": "address"
+            }
+        ],
+        "name": "getEthBalance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getLastBlockHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bool",
+                "name": "requireSuccess",
+                "type": "bool"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "address",
+                        "name": "target",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "callData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Call[]",
+                "name": "calls",
+                "type": "tuple[]"
+            }
+        ],
+        "name": "tryAggregate",
+        "outputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "bool",
+                        "name": "success",
+                        "type": "bool"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "returnData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Result[]",
+                "name": "returnData",
+                "type": "tuple[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bool",
+                "name": "requireSuccess",
+                "type": "bool"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "address",
+                        "name": "target",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "callData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Call[]",
+                "name": "calls",
+                "type": "tuple[]"
+            }
+        ],
+        "name": "tryBlockAndAggregate",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "blockNumber",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "bool",
+                        "name": "success",
+                        "type": "bool"
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "returnData",
+                        "type": "bytes"
+                    }
+                ],
+                "internalType": "struct Multicall2.Result[]",
+                "name": "returnData",
+                "type": "tuple[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+]

package/dist/cjs/utils/parseError.d.ts

@@ -0,0 +1,38 @@
+import { Process, Step } from '@lifi/types';
+import { LifiError } from './errors';
+/**
+ * Available MetaMask error codes:
+ *
+ * export const errorCodes: ErrorCodes = {
+     rpc: {
+      invalidInput: -32000,
+      resourceNotFound: -32001,
+      resourceUnavailable: -32002,
+      transactionRejected: -32003,
+      methodNotSupported: -32004,
+      limitExceeded: -32005,
+      parse: -32700,
+      invalidRequest: -32600,
+      methodNotFound: -32601,
+      invalidParams: -32602,
+      internal: -32603,
+    },
+    provider: {
+      userRejectedRequest: 4001,
+      unauthorized: 4100,
+      unsupportedMethod: 4200,
+      disconnected: 4900,
+      chainDisconnected: 4901,
+    },
+  };
+ *
+ * For more information about error codes supported by metamask check
+ * https://github.com/MetaMask/eth-rpc-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+export declare const getTransactionNotSentMessage: (step?: Step, process?: Process) => Promise<string>;
+export declare const getTransactionFailedMessage: (step: Step, txLink?: string) => string;
+export declare const parseError: (e: any, step?: Step, process?: Process) => Promise<LifiError>;
+export declare const parseBackendError: (e: any) => LifiError;
+export declare const getSlippageNotMetMessage: (step: Step) => string;

package/dist/cjs/utils/parseError.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 });
+exports.getSlippageNotMetMessage = exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
+const types_1 = require("@lifi/types");
+const eth_rpc_errors_1 = require("eth-rpc-errors");
+const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+/**
+ * Available MetaMask error codes:
+ *
+ * export const errorCodes: ErrorCodes = {
+     rpc: {
+      invalidInput: -32000,
+      resourceNotFound: -32001,
+      resourceUnavailable: -32002,
+      transactionRejected: -32003,
+      methodNotSupported: -32004,
+      limitExceeded: -32005,
+      parse: -32700,
+      invalidRequest: -32600,
+      methodNotFound: -32601,
+      invalidParams: -32602,
+      internal: -32603,
+    },
+    provider: {
+      userRejectedRequest: 4001,
+      unauthorized: 4100,
+      unsupportedMethod: 4200,
+      disconnected: 4900,
+      chainDisconnected: 4901,
+    },
+  };
+ *
+ * For more information about error codes supported by metamask check
+ * https://github.com/MetaMask/eth-rpc-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+const getTransactionNotSentMessage = (step, process) => __awaiter(void 0, void 0, void 0, function* () {
+    let transactionNotSend = 'Transaction was not sent, your funds are still in your wallet';
+    // add information about funds if available
+    if (step) {
+        const chainService = ChainsService_1.default.getInstance();
+        const chain = yield chainService.getChainById(step.action.fromChainId);
+        transactionNotSend += ` (${(0, utils_1.formatTokenAmountOnly)(step.action.fromToken, step.action.fromAmount)} ${step.action.fromToken.symbol} on ${chain.name})`;
+    }
+    transactionNotSend +=
+        ", please retry.<br/>If it still doesn't work, it is safe to delete this transfer and start a new one.";
+    // add transaction explorer link if available
+    transactionNotSend +=
+        process && process.txLink
+            ? `<br>You can check the failed transaction&nbsp;<a href="${process.txLink}" target="_blank" rel="nofollow noreferrer">here</a>.`
+            : '';
+    return transactionNotSend;
+});
+exports.getTransactionNotSentMessage = getTransactionNotSentMessage;
+const getTransactionFailedMessage = (step, txLink) => {
+    const baseString = `It appears that your transaction may not have been successful.
+  However, to confirm this, please check your ${(0, types_1.getChainById)(step.action.toChainId).name} wallet for ${step.action.toToken.symbol}.`;
+    return txLink
+        ? `${baseString}
+    You can also check the&nbsp;<a href="${txLink}" target="_blank" rel="nofollow noreferrer">block explorer</a> for more information.`
+        : baseString;
+};
+exports.getTransactionFailedMessage = getTransactionFailedMessage;
+const parseError = (e, step, process) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    if (e instanceof errors_1.LifiError) {
+        return e;
+    }
+    if (e.code) {
+        // MetaMask errors have a numeric error code
+        if (typeof e.code === 'number') {
+            if (Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(e.code)) {
+                // rpc errors
+                // underpriced errors are sent as internal errors, so we need to parse the message manually
+                if (e.code === eth_rpc_errors_1.errorCodes.rpc.internal &&
+                    e.message &&
+                    e.message.includes('underpriced')) {
+                    return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                }
+                if (((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('intrinsic gas too low')) ||
+                    ((_b = e.message) === null || _b === void 0 ? void 0 : _b.includes('out of gas'))) {
+                    return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, 'Gas limit is too low.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                }
+                return new errors_1.RPCError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            }
+            // provider errors
+            if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(e.code)) {
+                return new errors_1.ProviderError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            }
+        }
+        if (e.code === 'CALL_EXCEPTION') {
+            return new errors_1.ProviderError(errors_1.LifiErrorCode.TransactionFailed, e.reason, yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+        }
+        if (e.code === errors_1.LifiErrorCode.TransactionUnprepared) {
+            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, e.message, yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+        }
+        if (e.code === errors_1.LifiErrorCode.ValidationError) {
+            return new errors_1.TransactionError(errors_1.LifiErrorCode.ValidationError, e.message, e.htmlMessage);
+        }
+    }
+    return new errors_1.UnknownError(errors_1.LifiErrorCode.InternalError, e.message || 'Unknown error occurred.', undefined, e.stack);
+});
+exports.parseError = parseError;
+const parseBackendError = (e) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 400) {
+        return new errors_1.ValidationError(((_c = (_b = e.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || ((_d = e.response) === null || _d === void 0 ? void 0 : _d.statusText), undefined, e.stack);
+    }
+    if (((_e = e.response) === null || _e === void 0 ? void 0 : _e.status) === 404) {
+        return new errors_1.NotFoundError(((_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.message) || ((_h = e.response) === null || _h === void 0 ? void 0 : _h.statusText), undefined, e.stack);
+    }
+    if (((_j = e.response) === null || _j === void 0 ? void 0 : _j.status) === 409) {
+        return new errors_1.SlippageError(((_l = (_k = e.response) === null || _k === void 0 ? void 0 : _k.data) === null || _l === void 0 ? void 0 : _l.message) || ((_m = e.response) === null || _m === void 0 ? void 0 : _m.statusText), 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.', e.stack);
+    }
+    if (((_o = e.response) === null || _o === void 0 ? void 0 : _o.status) === 500) {
+        return new errors_1.ServerError(((_q = (_p = e.response) === null || _p === void 0 ? void 0 : _p.data) === null || _q === void 0 ? void 0 : _q.message) || ((_r = e.response) === null || _r === void 0 ? void 0 : _r.statusText), undefined, e.stack);
+    }
+    return new errors_1.ServerError('Something went wrong.', undefined, e.stack);
+};
+exports.parseBackendError = parseBackendError;
+const getSlippageNotMetMessage = (step) => {
+    const { slippage } = step.action;
+    return `Transaction was not sent, your funds are still in your wallet.
+  The updated quote for the current transaction does not meet your set slippage of ${slippage * 100}%.`;
+};
+exports.getSlippageNotMetMessage = getSlippageNotMetMessage;

package/dist/cjs/utils/preRestart.d.ts

@@ -0,0 +1,2 @@
+import { Route } from '../types';
+export declare const handlePreRestart: (route: Route) => void;

package/dist/cjs/utils/preRestart.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePreRestart = void 0;
+const errors_1 = require("./errors");
+const handlePreRestart = (route) => {
+    var _a;
+    for (let index = 0; index < route.steps.length; index++) {
+        const stepHasFailed = ((_a = route.steps[index].execution) === null || _a === void 0 ? void 0 : _a.status) === 'FAILED';
+        if (stepHasFailed) {
+            handleErrorType(route, index);
+            deleteFailedProcesses(route, index);
+        }
+    }
+};
+exports.handlePreRestart = handlePreRestart;
+const handleErrorType = (route, index) => {
+    var _a, _b, _c, _d;
+    const isGasLimitError = (_a = route.steps[index].execution) === null || _a === void 0 ? void 0 : _a.process.some((p) => { var _a; return ((_a = p.error) === null || _a === void 0 ? void 0 : _a.code) === errors_1.LifiErrorCode.GasLimitError; });
+    const isGasPriceError = (_b = route.steps[index].execution) === null || _b === void 0 ? void 0 : _b.process.some((p) => { var _a; return ((_a = p.error) === null || _a === void 0 ? void 0 : _a.code) === errors_1.LifiErrorCode.TransactionUnderpriced; });
+    if (isGasLimitError) {
+        (_c = route.steps[index].estimate.gasCosts) === null || _c === void 0 ? void 0 : _c.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
+    }
+    if (isGasPriceError) {
+        (_d = route.steps[index].estimate.gasCosts) === null || _d === void 0 ? void 0 : _d.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
+    }
+};
+const deleteFailedProcesses = (route, index) => {
+    if (route.steps[index].execution) {
+        route.steps[index].execution.process = route.steps[index].execution.process.filter((process) => process.status !== 'FAILED');
+    }
+};

package/dist/cjs/utils/utils.d.ts

@@ -0,0 +1,26 @@
+import { TransactionReceipt } from '@ethersproject/providers';
+import { Token } from '@lifi/types';
+import BigNumber from 'bignumber.js';
+import { Signer } from 'ethers';
+import { ChainId, Step } from '../types';
+export declare const deepClone: <T>(src: T) => T;
+export declare const sleep: (mills: number) => Promise<undefined>;
+export declare const personalizeStep: (signer: Signer, step: Step) => Promise<Step>;
+export declare const splitListIntoChunks: <T>(list: T[], chunkSize: number) => T[][];
+export declare const formatTokenAmountOnly: (token: Token, amount: string | BigNumber | undefined) => string;
+/**
+ * Repeatedly calls a given asynchronous function until it resolves with a value
+ * @param toRepeat The function that should be repeated
+ * @param timeout The timeout in milliseconds between retries, defaults to 5000
+ * @returns The result of the toRepeat function
+ */
+export declare const repeatUntilDone: <T>(toRepeat: () => Promise<T | undefined>, timeout?: number) => Promise<T>;
+/**
+ * Loads a transaction receipt using the rpc for the given chain id
+ * @param chainId The chain id where the transaction should be loaded from
+ * @param txHash The hash of the transaction
+ * @returns TransactionReceipt
+ */
+export declare const loadTransactionReceipt: (chainId: ChainId, txHash: string) => Promise<TransactionReceipt>;
+export declare const isZeroAddress: (address: string) => boolean;
+export declare const isNativeTokenAddress: (address: string) => boolean;

package/dist/cjs/utils/utils.js

@@ -0,0 +1,120 @@
+"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 });
+exports.isNativeTokenAddress = exports.isZeroAddress = exports.loadTransactionReceipt = exports.repeatUntilDone = exports.formatTokenAmountOnly = exports.splitListIntoChunks = exports.personalizeStep = exports.sleep = exports.deepClone = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const connectors_1 = require("../connectors");
+const deepClone = (src) => {
+    return JSON.parse(JSON.stringify(src));
+};
+exports.deepClone = deepClone;
+const sleep = (mills) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, mills);
+    });
+};
+exports.sleep = sleep;
+const personalizeStep = (signer, step) => __awaiter(void 0, void 0, void 0, function* () {
+    if (step.action.toAddress && step.action.fromAddress) {
+        return step;
+    }
+    const address = yield signer.getAddress();
+    const fromAddress = step.action.fromAddress || address;
+    const toAddress = step.action.toAddress || address;
+    return Object.assign(Object.assign({}, step), { action: Object.assign(Object.assign({}, step.action), { fromAddress,
+            toAddress }) });
+});
+exports.personalizeStep = personalizeStep;
+const splitListIntoChunks = (list, chunkSize) => list.reduce((resultList, item, index) => {
+    const chunkIndex = Math.floor(index / chunkSize);
+    if (!resultList[chunkIndex]) {
+        resultList[chunkIndex] = []; // start a new chunk
+    }
+    resultList[chunkIndex].push(item);
+    return resultList;
+}, []);
+exports.splitListIntoChunks = splitListIntoChunks;
+const formatTokenAmountOnly = (token, amount) => {
+    if (!amount) {
+        return '0.0';
+    }
+    let floated;
+    if (typeof amount === 'string') {
+        if (amount === '0') {
+            return '0.0';
+        }
+        floated = new bignumber_js_1.default(amount).shiftedBy(-token.decimals);
+    }
+    else {
+        floated = amount;
+        if (floated.isZero()) {
+            return '0.0';
+        }
+    }
+    // show at least 4 decimal places and at least two non-zero digests
+    let decimalPlaces = 3;
+    while (floated.lt(1 / Math.pow(10, decimalPlaces))) {
+        decimalPlaces++;
+    }
+    return floated.toFixed(decimalPlaces + 1, 1);
+};
+exports.formatTokenAmountOnly = formatTokenAmountOnly;
+/**
+ * Repeatedly calls a given asynchronous function until it resolves with a value
+ * @param toRepeat The function that should be repeated
+ * @param timeout The timeout in milliseconds between retries, defaults to 5000
+ * @returns The result of the toRepeat function
+ */
+const repeatUntilDone = (toRepeat, timeout = 5000) => __awaiter(void 0, void 0, void 0, function* () {
+    let result;
+    while (!result) {
+        result = yield toRepeat();
+        if (!result) {
+            yield (0, exports.sleep)(timeout);
+        }
+    }
+    return result;
+});
+exports.repeatUntilDone = repeatUntilDone;
+/**
+ * Loads a transaction receipt using the rpc for the given chain id
+ * @param chainId The chain id where the transaction should be loaded from
+ * @param txHash The hash of the transaction
+ * @returns TransactionReceipt
+ */
+const loadTransactionReceipt = (chainId, txHash) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
+    const tx = yield rpc.getTransaction(txHash);
+    return tx.wait();
+});
+exports.loadTransactionReceipt = loadTransactionReceipt;
+const isZeroAddress = (address) => {
+    if (address === ethers_1.constants.AddressZero ||
+        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+        return true;
+    }
+    return false;
+};
+exports.isZeroAddress = isZeroAddress;
+const isNativeTokenAddress = (address) => {
+    if (address === ethers_1.constants.AddressZero ||
+        address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
+        // CELO native token
+        address === '0x471ece3750da237f93b8e339c536989b8978a438') {
+        return true;
+    }
+    return false;
+};
+exports.isNativeTokenAddress = isNativeTokenAddress;