@lifi/sdk 1.1.0 → 1.1.3

package/dist/services/ChainsService.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,101 +7,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-var errors_1 = require("../utils/errors");
-var ApiService_1 = __importDefault(require("./ApiService"));
-var ChainsService = /** @class */ (function () {
-    function ChainsService() {
+import { ValidationError } from '../utils/errors';
+import ApiService from './ApiService';
+export default class ChainsService {
+    constructor() {
         this.chains = [];
         this.loadingPromise = this.loadAvailableChains();
     }
-    ChainsService.prototype.loadAvailableChains = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this;
-                        return [4 /*yield*/, ApiService_1.default.getChains()];
-                    case 1:
-                        _a.chains = _b.sent();
-                        return [2 /*return*/];
-                }
-            });
+    loadAvailableChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.chains = yield ApiService.getChains();
         });
-    };
-    ChainsService.getInstance = function () {
+    }
+    static getInstance() {
         if (!this.instance) {
             this.instance = new ChainsService();
         }
         return this.instance;
-    };
-    ChainsService.prototype.getChainById = function (chainId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var chain;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.loadingPromise) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.loadingPromise];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        chain = this.chains.find(function (chain) { return chain.id === chainId; });
-                        if (!chain) {
-                            throw new errors_1.ValidationError("Unknown chainId passed: ".concat(chainId, "."));
-                        }
-                        return [2 /*return*/, chain];
-                }
-            });
+    }
+    getChainById(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadingPromise) {
+                yield this.loadingPromise;
+            }
+            const chain = this.chains.find((chain) => chain.id === chainId);
+            if (!chain) {
+                throw new ValidationError(`Unknown chainId passed: ${chainId}.`);
+            }
+            return chain;
         });
-    };
-    ChainsService.prototype.getChains = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.loadingPromise) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.loadingPromise];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, this.chains];
-                }
-            });
+    }
+    getChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadingPromise) {
+                yield this.loadingPromise;
+            }
+            return this.chains;
         });
-    };
-    return ChainsService;
-}());
-exports.default = ChainsService;
+    }
+}

package/dist/services/ConfigService.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,127 +7,89 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var types_1 = require("../types");
-var DefaultExecutionSettings = {
+import { ChainId, } from '../types';
+const DefaultExecutionSettings = {
     /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    updateCallback: function () { },
-    switchChainHook: function () { return Promise.resolve(undefined); },
-    acceptSlippageUpdateHook: function () { return Promise.resolve(undefined); },
+    updateCallback: () => { },
+    switchChainHook: () => Promise.resolve(undefined),
+    acceptSlippageUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
 };
-var ConfigService = /** @class */ (function () {
-    function ConfigService() {
-        var _this = this;
+export default class ConfigService {
+    constructor() {
         this.resolveSetupPromise = undefined;
         /**
          * This call immediately returns the current config. It does not make sure that all chain data is already loaded
          * Use this if you need access to basic information like API urls or settings
          */
-        this.getConfig = function () {
-            return _this.config;
+        this.getConfig = () => {
+            return this.config;
         };
         /**
          * This call waits for all setup promises to be done.
          * Use this if you need access to chain data (RPCs or multicalls)
          */
-        this.getConfigAsync = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.setupPromise];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.config];
-                }
-            });
-        }); };
-        this.updateConfig = function (configUpdate) {
+        this.getConfigAsync = () => __awaiter(this, void 0, void 0, function* () {
+            yield this.setupPromise;
+            return this.config;
+        });
+        this.updateConfig = (configUpdate) => {
             // API
-            _this.config.apiUrl = configUpdate.apiUrl || _this.config.apiUrl;
+            this.config.apiUrl = configUpdate.apiUrl || this.config.apiUrl;
             // RPCS
-            _this.config.rpcs = Object.assign(_this.config.rpcs, configUpdate.rpcs);
+            this.config.rpcs = Object.assign(this.config.rpcs, configUpdate.rpcs);
             // MULTICALL
-            _this.config.multicallAddresses = Object.assign(_this.config.multicallAddresses, configUpdate.multicallAddresses);
+            this.config.multicallAddresses = Object.assign(this.config.multicallAddresses, configUpdate.multicallAddresses);
             // SETTINGS
-            _this.config.defaultExecutionSettings = Object.assign(_this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
+            this.config.defaultExecutionSettings = Object.assign(this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
             // OPTIONS
-            _this.config.defaultRouteOptions = Object.assign(_this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
-            return _this.config;
+            this.config.defaultRouteOptions = Object.assign(this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
+            return this.config;
         };
-        this.updateChains = function (chains) {
+        this.updateChains = (chains) => {
             var _a;
-            for (var _i = 0, chains_1 = chains; _i < chains_1.length; _i++) {
-                var chain = chains_1[_i];
-                var chainId = chain.id;
+            for (const chain of chains) {
+                const chainId = chain.id;
                 // set RPCs if they were not configured by the user before
-                if (!_this.config.rpcs[chainId].length) {
-                    _this.config.rpcs[chainId] = chain.metamask.rpcUrls;
+                if (!this.config.rpcs[chainId].length) {
+                    this.config.rpcs[chainId] = chain.metamask.rpcUrls;
                 }
                 // set multicall addresses if they exist and were not configured by the user before
-                if (chain.multicallAddress && !_this.config.multicallAddresses[chainId]) {
-                    _this.config.multicallAddresses[chainId] = chain.multicallAddress;
+                if (chain.multicallAddress && !this.config.multicallAddresses[chainId]) {
+                    this.config.multicallAddresses[chainId] = chain.multicallAddress;
                 }
             }
-            (_a = _this.resolveSetupPromise) === null || _a === void 0 ? void 0 : _a.call(_this);
-            return _this.config;
+            (_a = this.resolveSetupPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+            return this.config;
         };
         this.config = ConfigService.getDefaultConfig();
-        this.setupPromise = new Promise(function (resolve) {
-            _this.resolveSetupPromise = resolve;
+        this.setupPromise = new Promise((resolve) => {
+            this.resolveSetupPromise = resolve;
         });
     }
-    ConfigService.chainIdToObject = function (val) {
-        var result = {};
-        var values = Object.values(types_1.ChainId);
-        values.forEach(function (chainId) {
+    static chainIdToObject(val) {
+        const result = {};
+        const values = Object.values(ChainId);
+        values.forEach((chainId) => {
             if (typeof chainId !== 'string') {
                 result[chainId] = val ? JSON.parse(JSON.stringify(val)) : val;
             }
         });
         return result;
-    };
-    ConfigService.getInstance = function () {
+    }
+    static getInstance() {
         if (!this.instance) {
             this.instance = new ConfigService();
         }
         return this.instance;
+    }
+}
+ConfigService.getDefaultConfig = () => {
+    return {
+        apiUrl: 'https://li.quest/v1/',
+        rpcs: ConfigService.chainIdToObject([]),
+        multicallAddresses: ConfigService.chainIdToObject(undefined),
+        defaultExecutionSettings: DefaultExecutionSettings,
+        defaultRouteOptions: {},
     };
-    ConfigService.getDefaultConfig = function () {
-        return {
-            apiUrl: 'https://li.quest/v1/',
-            rpcs: ConfigService.chainIdToObject([]),
-            multicallAddresses: ConfigService.chainIdToObject(undefined),
-            defaultExecutionSettings: DefaultExecutionSettings,
-            defaultRouteOptions: {},
-        };
-    };
-    return ConfigService;
-}());
-exports.default = ConfigService;
+};

package/dist/typeguards.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isToken = exports.isStep = exports.isRoutesRequest = void 0;
-var isRoutesRequest = function (routesRequest) {
-    var fromChainId = routesRequest.fromChainId, fromAmount = routesRequest.fromAmount, fromTokenAddress = routesRequest.fromTokenAddress, toChainId = routesRequest.toChainId, toTokenAddress = routesRequest.toTokenAddress, options = routesRequest.options;
+export const isRoutesRequest = (routesRequest) => {
+    const { fromChainId, fromAmount, fromTokenAddress, toChainId, toTokenAddress, options, } = routesRequest;
     return (typeof fromChainId === 'number' &&
         typeof fromAmount === 'string' &&
         fromAmount !== '' &&
@@ -13,31 +10,27 @@ var isRoutesRequest = function (routesRequest) {
         toTokenAddress !== '' &&
         (!options || isRoutesOptions(options)));
 };
-exports.isRoutesRequest = isRoutesRequest;
-var isRoutesOptions = function (routeOptions) {
-    return !(routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.slippage) || typeof routeOptions.slippage === 'number';
-};
-var isStep = function (step) {
-    var id = step.id, type = step.type, tool = step.tool, action = step.action, estimate = step.estimate;
+const isRoutesOptions = (routeOptions) => !(routeOptions === null || routeOptions === void 0 ? void 0 : routeOptions.slippage) || typeof routeOptions.slippage === 'number';
+export const isStep = (step) => {
+    const { id, type, tool, action, estimate } = step;
     return (typeof id === 'string' &&
         ['swap', 'cross', 'lifi'].includes(type) &&
         typeof tool === 'string' &&
         isAction(action) &&
         isEstimate(estimate));
 };
-exports.isStep = isStep;
-var isAction = function (action) {
-    var fromChainId = action.fromChainId, fromAmount = action.fromAmount, fromToken = action.fromToken, toChainId = action.toChainId, toToken = action.toToken, slippage = action.slippage;
+const isAction = (action) => {
+    const { fromChainId, fromAmount, fromToken, toChainId, toToken, slippage } = action;
     return (typeof fromChainId === 'number' &&
         typeof fromAmount === 'string' &&
         fromAmount !== '' &&
-        (0, exports.isToken)(fromToken) &&
+        isToken(fromToken) &&
         typeof toChainId === 'number' &&
-        (0, exports.isToken)(toToken) &&
+        isToken(toToken) &&
         typeof slippage === 'number');
 };
-var isEstimate = function (estimate) {
-    var fromAmount = estimate.fromAmount, toAmount = estimate.toAmount, toAmountMin = estimate.toAmountMin, approvalAddress = estimate.approvalAddress;
+const isEstimate = (estimate) => {
+    const { fromAmount, toAmount, toAmountMin, approvalAddress } = estimate;
     return (typeof fromAmount === 'string' &&
         fromAmount !== '' &&
         typeof toAmount === 'string' &&
@@ -46,10 +39,9 @@ var isEstimate = function (estimate) {
         toAmountMin !== '' &&
         typeof approvalAddress === 'string');
 };
-var isToken = function (token) {
-    var address = token.address, decimals = token.decimals, chainId = token.chainId;
+export const isToken = (token) => {
+    const { address, decimals, chainId } = token;
     return (typeof address === 'string' &&
         typeof decimals === 'number' &&
         typeof chainId === 'number');
 };
-exports.isToken = isToken;

package/dist/types/ERC20.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ERC20_ABI = void 0;
-exports.ERC20_ABI = [
+export const ERC20_ABI = [
     {
         name: 'approve',
         inputs: [

package/dist/types/index.js

@@ -1,22 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LifiError = void 0;
-__exportStar(require("@lifi/types"), exports);
-var errors_1 = require("../utils/errors");
-Object.defineProperty(exports, "LifiError", { enumerable: true, get: function () { return errors_1.LifiError; } });
-__exportStar(require("./ERC20"), exports);
-__exportStar(require("./internal.types"), exports);
+export * from '@lifi/types';
+export { LifiError } from '../utils/errors';
+export * from './ERC20';
+export * from './internal.types';

package/dist/types/internal.types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/utils/errors.js

@@ -1,21 +1,3 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownError = exports.NotFoundError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
 var ErrorType;
 (function (ErrorType) {
     ErrorType["RPCError"] = "RPCError";
@@ -27,7 +9,7 @@ var ErrorType;
     ErrorType["UnknownError"] = "UnknownError";
     ErrorType["SlippageError"] = "SlippageError";
 })(ErrorType || (ErrorType = {}));
-var LifiErrorCode;
+export var LifiErrorCode;
 (function (LifiErrorCode) {
     LifiErrorCode[LifiErrorCode["InternalError"] = 1000] = "InternalError";
     LifiErrorCode[LifiErrorCode["ValidationError"] = 1001] = "ValidationError";
@@ -41,8 +23,8 @@ var LifiErrorCode;
     LifiErrorCode[LifiErrorCode["SlippageNotMet"] = 1008] = "SlippageNotMet";
     LifiErrorCode[LifiErrorCode["SlippageError"] = 1008] = "SlippageError";
     LifiErrorCode[LifiErrorCode["GasLimitError"] = 1009] = "GasLimitError";
-})(LifiErrorCode = exports.LifiErrorCode || (exports.LifiErrorCode = {}));
-var MetaMaskRPCErrorCode;
+})(LifiErrorCode || (LifiErrorCode = {}));
+export var MetaMaskRPCErrorCode;
 (function (MetaMaskRPCErrorCode) {
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidInput"] = -32000] = "invalidInput";
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["resourceNotFound"] = -32001] = "resourceNotFound";
@@ -55,95 +37,67 @@ var MetaMaskRPCErrorCode;
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["methodNotFound"] = -32601] = "methodNotFound";
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["invalidParams"] = -32602] = "invalidParams";
     MetaMaskRPCErrorCode[MetaMaskRPCErrorCode["internal"] = -32603] = "internal";
-})(MetaMaskRPCErrorCode = exports.MetaMaskRPCErrorCode || (exports.MetaMaskRPCErrorCode = {}));
-var MetaMaskProviderErrorCode;
+})(MetaMaskRPCErrorCode || (MetaMaskRPCErrorCode = {}));
+export var MetaMaskProviderErrorCode;
 (function (MetaMaskProviderErrorCode) {
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["userRejectedRequest"] = 4001] = "userRejectedRequest";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["unauthorized"] = 4100] = "unauthorized";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["unsupportedMethod"] = 4200] = "unsupportedMethod";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["disconnected"] = 4900] = "disconnected";
     MetaMaskProviderErrorCode[MetaMaskProviderErrorCode["chainDisconnected"] = 4901] = "chainDisconnected";
-})(MetaMaskProviderErrorCode = exports.MetaMaskProviderErrorCode || (exports.MetaMaskProviderErrorCode = {}));
-var LifiError = /** @class */ (function (_super) {
-    __extends(LifiError, _super);
-    function LifiError(type, code, message, htmlMessage, stack) {
-        var _this = _super.call(this, message) || this;
+})(MetaMaskProviderErrorCode || (MetaMaskProviderErrorCode = {}));
+export class LifiError extends Error {
+    constructor(type, code, message, htmlMessage, stack) {
+        super(message);
         // Set the prototype explicitly: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(_this, LifiError.prototype);
-        _this.code = code;
+        Object.setPrototypeOf(this, LifiError.prototype);
+        this.code = code;
         // the name property is used by toString(). It is a string and we can't use our custom ErrorTypes, that's why we have to cast
-        _this.name = type.toString();
-        _this.htmlMessage = htmlMessage;
+        this.name = type.toString();
+        this.htmlMessage = htmlMessage;
         // passing a stack allows us to preserve the stack from errors that we caught and just want to transform in one of our custom errors
         if (stack) {
-            _this.stack = stack;
+            this.stack = stack;
         }
-        return _this;
     }
-    return LifiError;
-}(Error));
-exports.LifiError = LifiError;
-var RPCError = /** @class */ (function (_super) {
-    __extends(RPCError, _super);
-    function RPCError(code, message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.RPCError, code, message, htmlMessage, stack) || this;
+}
+export class RPCError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.RPCError, code, message, htmlMessage, stack);
     }
-    return RPCError;
-}(LifiError));
-exports.RPCError = RPCError;
-var ProviderError = /** @class */ (function (_super) {
-    __extends(ProviderError, _super);
-    function ProviderError(code, message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.ProviderError, code, message, htmlMessage, stack) || this;
+}
+export class ProviderError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.ProviderError, code, message, htmlMessage, stack);
     }
-    return ProviderError;
-}(LifiError));
-exports.ProviderError = ProviderError;
-var ServerError = /** @class */ (function (_super) {
-    __extends(ServerError, _super);
-    function ServerError(message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack) || this;
+}
+export class ServerError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.ServerError, LifiErrorCode.InternalError, message, htmlMessage, stack);
     }
-    return ServerError;
-}(LifiError));
-exports.ServerError = ServerError;
-var ValidationError = /** @class */ (function (_super) {
-    __extends(ValidationError, _super);
-    function ValidationError(message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack) || this;
+}
+export class ValidationError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.ValidationError, LifiErrorCode.ValidationError, message, htmlMessage, stack);
     }
-    return ValidationError;
-}(LifiError));
-exports.ValidationError = ValidationError;
-var TransactionError = /** @class */ (function (_super) {
-    __extends(TransactionError, _super);
-    function TransactionError(code, message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.TransactionError, code, message, htmlMessage, stack) || this;
+}
+export class TransactionError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.TransactionError, code, message, htmlMessage, stack);
     }
-    return TransactionError;
-}(LifiError));
-exports.TransactionError = TransactionError;
-var SlippageError = /** @class */ (function (_super) {
-    __extends(SlippageError, _super);
-    function SlippageError(message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack) || this;
+}
+export class SlippageError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.SlippageError, LifiErrorCode.SlippageError, message, htmlMessage, stack);
     }
-    return SlippageError;
-}(LifiError));
-exports.SlippageError = SlippageError;
-var NotFoundError = /** @class */ (function (_super) {
-    __extends(NotFoundError, _super);
-    function NotFoundError(message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack) || this;
+}
+export class NotFoundError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack);
     }
-    return NotFoundError;
-}(LifiError));
-exports.NotFoundError = NotFoundError;
-var UnknownError = /** @class */ (function (_super) {
-    __extends(UnknownError, _super);
-    function UnknownError(code, message, htmlMessage, stack) {
-        return _super.call(this, ErrorType.UnknownError, code, message, htmlMessage, stack) || this;
+}
+export class UnknownError extends LifiError {
+    constructor(code, message, htmlMessage, stack) {
+        super(ErrorType.UnknownError, code, message, htmlMessage, stack);
     }
-    return UnknownError;
-}(LifiError));
-exports.UnknownError = UnknownError;
+}

package/dist/utils/getProvider.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProvider = void 0;
-var errors_1 = require("./errors");
-var getProvider = function (signer) {
+import { LifiErrorCode, ProviderError } from './errors';
+export const getProvider = (signer) => {
     if (!signer.provider) {
-        throw new errors_1.ProviderError(errors_1.LifiErrorCode.ProviderUnavailable, 'No provider available in signer.');
+        throw new ProviderError(LifiErrorCode.ProviderUnavailable, 'No provider available in signer.');
     }
     return signer.provider;
 };
-exports.getProvider = getProvider;