@lifi/sdk 1.0.0

package/dist/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/utils/parseError.d.ts

@@ -0,0 +1,37 @@
+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;

package/dist/utils/parseError.js

@@ -0,0 +1,184 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
+var types_1 = require("@lifi/types");
+var eth_rpc_errors_1 = require("eth-rpc-errors");
+var ChainsService_1 = __importDefault(require("../services/ChainsService"));
+var errors_1 = require("./errors");
+var 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
+ */
+var getTransactionNotSentMessage = function (step, process) { return __awaiter(void 0, void 0, void 0, function () {
+    var transactionNotSend, chainService, chain;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                transactionNotSend = 'Transaction was not sent, your funds are still in your wallet';
+                if (!step) return [3 /*break*/, 2];
+                chainService = ChainsService_1.default.getInstance();
+                return [4 /*yield*/, chainService.getChainById(step.action.fromChainId)];
+            case 1:
+                chain = _a.sent();
+                transactionNotSend += " (".concat((0, utils_1.formatTokenAmountOnly)(step.action.fromToken, step.action.fromAmount), " ").concat(step.action.fromToken.symbol, " on ").concat(chain.name, ")");
+                _a.label = 2;
+            case 2:
+                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=\"".concat(process.txLink, "\" target=\"_blank\" rel=\"nofollow noreferrer\">here</a>.")
+                        : '';
+                return [2 /*return*/, transactionNotSend];
+        }
+    });
+}); };
+exports.getTransactionNotSentMessage = getTransactionNotSentMessage;
+var getTransactionFailedMessage = function (step, txLink) {
+    var baseString = "It appears that your transaction may not have been successful.\n  However, to confirm this, please check your ".concat((0, types_1.getChainById)(step.action.toChainId).name, " wallet for ").concat(step.action.toToken.symbol, ".");
+    return txLink
+        ? "".concat(baseString, "\n    You can also check the&nbsp;<a href=\"").concat(txLink, "\" target=\"_blank\" rel=\"nofollow noreferrer\">block explorer</a> for more information.")
+        : baseString;
+};
+exports.getTransactionFailedMessage = getTransactionFailedMessage;
+var parseError = function (e, step, process) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    return __generator(this, function (_l) {
+        switch (_l.label) {
+            case 0:
+                if (e instanceof errors_1.LifiError) {
+                    return [2 /*return*/, e];
+                }
+                if (!e.code) return [3 /*break*/, 11];
+                if (!(typeof e.code === 'number')) return [3 /*break*/, 6];
+                if (!Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(e.code)) return [3 /*break*/, 4];
+                if (!(e.code === eth_rpc_errors_1.errorCodes.rpc.internal &&
+                    e.message &&
+                    e.message.includes('underpriced'))) return [3 /*break*/, 2];
+                _a = errors_1.RPCError.bind;
+                _b = [void 0, errors_1.LifiErrorCode.TransactionUnderpriced,
+                    'Transaction is underpriced.'];
+                return [4 /*yield*/, (0, exports.getTransactionNotSentMessage)(step, process)];
+            case 1: return [2 /*return*/, new (_a.apply(errors_1.RPCError, _b.concat([_l.sent(), e.stack])))()];
+            case 2:
+                _c = errors_1.RPCError.bind;
+                _d = [void 0, e.code,
+                    (0, eth_rpc_errors_1.getMessageFromCode)(e.code)];
+                return [4 /*yield*/, (0, exports.getTransactionNotSentMessage)(step, process)];
+            case 3: return [2 /*return*/, new (_c.apply(errors_1.RPCError, _d.concat([_l.sent(), e.stack])))()];
+            case 4:
+                if (!Object.values(eth_rpc_errors_1.errorCodes.provider).includes(e.code)) return [3 /*break*/, 6];
+                _e = errors_1.ProviderError.bind;
+                _f = [void 0, e.code,
+                    (0, eth_rpc_errors_1.getMessageFromCode)(e.code)];
+                return [4 /*yield*/, (0, exports.getTransactionNotSentMessage)(step, process)];
+            case 5: return [2 /*return*/, new (_e.apply(errors_1.ProviderError, _f.concat([_l.sent(), e.stack])))()];
+            case 6:
+                if (!(e.code === 'CALL_EXCEPTION')) return [3 /*break*/, 8];
+                _g = errors_1.ProviderError.bind;
+                _h = [void 0, errors_1.LifiErrorCode.TransactionFailed,
+                    e.reason];
+                return [4 /*yield*/, (0, exports.getTransactionNotSentMessage)(step, process)];
+            case 7: return [2 /*return*/, new (_g.apply(errors_1.ProviderError, _h.concat([_l.sent(), e.stack])))()];
+            case 8:
+                if (!(e.code === errors_1.LifiErrorCode.TransactionUnprepared)) return [3 /*break*/, 10];
+                _j = errors_1.TransactionError.bind;
+                _k = [void 0, errors_1.LifiErrorCode.TransactionUnprepared,
+                    e.message];
+                return [4 /*yield*/, (0, exports.getTransactionNotSentMessage)(step, process)];
+            case 9: return [2 /*return*/, new (_j.apply(errors_1.TransactionError, _k.concat([_l.sent(), e.stack])))()];
+            case 10:
+                if (e.code === errors_1.LifiErrorCode.ValidationError) {
+                    return [2 /*return*/, new errors_1.TransactionError(errors_1.LifiErrorCode.ValidationError, e.message, e.htmlMessage)];
+                }
+                _l.label = 11;
+            case 11: return [2 /*return*/, new errors_1.UnknownError(errors_1.LifiErrorCode.InternalError, e.message || 'Unknown error occurred.', undefined, e.stack)];
+        }
+    });
+}); };
+exports.parseError = parseError;
+var parseBackendError = function (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;

package/dist/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;