essential-eth 0.9.0 → 0.9.1-next.1

package/dist/cjs/providers/FallthroughProvider.js

@@ -1,134 +1,64 @@
-function _assertThisInitialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-}
-function _possibleConstructorReturn(self, call) {
-    if (call && (_typeof(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assertThisInitialized(self);
-}
-function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _setPrototypeOf(o, p);
-}
-var _typeof = function(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
-function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-    return function _createSuperInternal() {
-        var Super = _getPrototypeOf(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _getPrototypeOf(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possibleConstructorReturn(this, result);
-    };
-}
-import { logger } from "../logger/logger";
-import { BaseProvider } from "./BaseProvider";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallthroughProvider = void 0;
+const logger_1 = require("../logger/logger");
+const BaseProvider_1 = require("./BaseProvider");
 // https://advancedweb.hu/how-to-add-timeout-to-a-promise-in-javascript/
-var promiseTimeout = function(prom, time) {
-    return new Promise(function(resolve, reject) {
-        var timeout = setTimeout(function() {
-            return reject(new Error("Promise timed out"));
-        }, time);
-        prom.then(function(result) {
-            clearTimeout(timeout);
-            resolve(result);
-        }).catch(function(error) {
-            clearTimeout(timeout);
-            reject(error);
-        });
+const promiseTimeout = (prom, time) => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Promise timed out')), time);
+    prom
+        .then((result) => {
+        clearTimeout(timeout);
+        resolve(result);
+    })
+        .catch((error) => {
+        clearTimeout(timeout);
+        reject(error);
     });
-};
-var DEFAULT_TIMEOUT_DURATION = 8000;
+});
+const DEFAULT_TIMEOUT_DURATION = 8000;
 /**
  * @beta
  * A JSON RPC Provider which moves to the next URL when one fails.
- */ export var FallthroughProvider = /*#__PURE__*/ function(BaseProvider) {
-    "use strict";
-    _inherits(FallthroughProvider, BaseProvider);
-    var _super = _createSuper(FallthroughProvider);
-    function FallthroughProvider(rpcUrls) {
-        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-        _classCallCheck(this, FallthroughProvider);
-        var _this;
+ */
+class FallthroughProvider extends BaseProvider_1.BaseProvider {
+    /**
+     * @ignore
+     */
+    selectRpcUrl() {
+        return this._rpcUrls[this.rpcUrlCounter];
+    }
+    constructor(rpcUrls, options = {}) {
         if (!Array.isArray(rpcUrls)) {
-            logger.throwError("Array required", {
-                rpcUrls: rpcUrls
-            });
+            logger_1.logger.throwError('Array required', { rpcUrls });
         }
         if (rpcUrls.length <= 1) {
-            logger.throwError("More than one rpcUrl is required", {
-                rpcUrls: rpcUrls
-            });
+            logger_1.logger.throwError('More than one rpcUrl is required', { rpcUrls });
         }
-        _this = _super.call(this, rpcUrls);
+        super(rpcUrls);
         // index of current trusted rpc url
         /**
-   * @ignore
-   */ _this.rpcUrlCounter = 0;
+         * @ignore
+         */
+        this.rpcUrlCounter = 0;
         /**
-   * @ignore
-   */ _this.post = function(body) {
+         * @ignore
+         */
+        this.post = (body) => {
             // while failing post, add to rpcUrlCounter and post again
-            var genesisCount = _this.rpcUrlCounter;
-            var recursivePostRetry = function() {
+            const genesisCount = this.rpcUrlCounter;
+            const recursivePostRetry = () => {
                 // Times out request
-                var genesisRpcUrl = _this.selectRpcUrl();
-                var res = promiseTimeout(_this._post(body), _this.timeoutDuration).catch(function(e) {
+                const genesisRpcUrl = this.selectRpcUrl();
+                const res = promiseTimeout(this._post(body), this.timeoutDuration).catch((e) => {
                     // A mutex: Only add if no other instance has discovered this url as failing yet
-                    if (genesisRpcUrl === _this.selectRpcUrl()) {
+                    if (genesisRpcUrl === this.selectRpcUrl()) {
                         // add one and handle array overflow
-                        _this.rpcUrlCounter = (_this.rpcUrlCounter + 1) % _this._rpcUrls.length;
+                        this.rpcUrlCounter =
+                            (this.rpcUrlCounter + 1) % this._rpcUrls.length;
                     }
                     // we've already tried this rpc, throw for good
-                    if (_this.rpcUrlCounter === genesisCount) {
+                    if (this.rpcUrlCounter === genesisCount) {
                         throw e;
                     }
                     return recursivePostRetry();
@@ -137,14 +67,7 @@ var DEFAULT_TIMEOUT_DURATION = 8000;
             };
             return recursivePostRetry();
         };
-        _this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
-        return _this;
+        this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
     }
-    var _proto = FallthroughProvider.prototype;
-    /**
-   * @ignore
-   */ _proto.selectRpcUrl = function selectRpcUrl() {
-        return this._rpcUrls[this.rpcUrlCounter];
-    };
-    return FallthroughProvider;
-}(BaseProvider);
+}
+exports.FallthroughProvider = FallthroughProvider;

package/dist/cjs/providers/JsonRpcProvider.js

@@ -1,99 +1,32 @@
-function _assertThisInitialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-}
-function _possibleConstructorReturn(self, call) {
-    if (call && (_typeof(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assertThisInitialized(self);
-}
-function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _setPrototypeOf(o, p);
-}
-var _typeof = function(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
-function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-    return function _createSuperInternal() {
-        var Super = _getPrototypeOf(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _getPrototypeOf(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possibleConstructorReturn(this, result);
-    };
-}
-import { BaseProvider } from "./BaseProvider";
-export var JsonRpcProvider = /*#__PURE__*/ function(BaseProvider) {
-    "use strict";
-    _inherits(JsonRpcProvider, BaseProvider);
-    var _super = _createSuper(JsonRpcProvider);
-    function JsonRpcProvider() {
-        var rpcUrl = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "https://free-eth-node.com/api/eth";
-        _classCallCheck(this, JsonRpcProvider);
-        return _super.call(this, [
-            rpcUrl
-        ]);
-    }
-    var _proto = JsonRpcProvider.prototype;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonRpcProvider = exports.JsonRpcProvider = void 0;
+const BaseProvider_1 = require("./BaseProvider");
+class JsonRpcProvider extends BaseProvider_1.BaseProvider {
     /**
-   * @ignore
-   */ _proto.selectRpcUrl = function selectRpcUrl() {
+     * @ignore
+     */
+    selectRpcUrl() {
         return this._rpcUrls[0];
-    };
+    }
     /**
-   * @ignore
-   */ _proto.post = function post(body) {
+     * @ignore
+     */
+    post(body) {
         return this._post(body);
-    };
-    return JsonRpcProvider;
-}(BaseProvider);
+    }
+    /**
+     * @param rpcUrl The URL to your Eth node. Consider POKT or Infura
+     * @example
+     * `https://free-eth-node.com/api/eth`
+     * @example
+     * `https://mainnet.infura.io/v3/YOUR-PROJECT-ID`
+     */
+    constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
+        super([rpcUrl]);
+    }
+}
+exports.JsonRpcProvider = JsonRpcProvider;
 /**
  * Helper function to avoid "new"
  *
@@ -106,6 +39,8 @@ export var JsonRpcProvider = /*#__PURE__*/ function(BaseProvider) {
  * })
  * // 14530496
  * ```
- */ export function jsonRpcProvider(rpcUrl) {
+ */
+function jsonRpcProvider(rpcUrl) {
     return new JsonRpcProvider(rpcUrl);
 }
+exports.jsonRpcProvider = jsonRpcProvider;

package/dist/cjs/providers/test/json-rpc-provider/get-logs/mocks.d.ts

@@ -0,0 +1,14 @@
+import type { Filter } from '../../../../types/Filter.types';
+import type { RPCLog } from '../../../../types/Transaction.types';
+export declare const STRONGBLOCK_ADDRESS = "0xfbddadd80fe7bda00b901fbaf73803f2238ae655";
+export declare const filterAddressFromTo: Filter;
+export declare const RARELAND_ADDRESS = "0x596a0f276ee432d8a28441e55737ff55cf30d0f7";
+export declare const filterAddressTopics: Filter;
+export declare const WETH_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+export declare const filterAll: Filter;
+export declare const mockfilterAddressFromToLogs: RPCLog[];
+export declare const mockfilterAddressTopicsLogs: RPCLog[];
+export declare const mockfilterAllLogs: RPCLog[];
+export declare const mockRpcAddressFromToResponse: string;
+export declare const mockRpcAddressTopicsResponse: string;
+export declare const mockRpcAllResponse: string;

package/dist/cjs/providers/test/json-rpc-provider/get-logs/mocks.js

@@ -0,0 +1,152 @@
+"use strict";
+// Example logs that should be returned
+// https://etherscan.io/address/0xfbddadd80fe7bda00b901fbaf73803f2238ae655#events
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockRpcAllResponse = exports.mockRpcAddressTopicsResponse = exports.mockRpcAddressFromToResponse = exports.mockfilterAllLogs = exports.mockfilterAddressTopicsLogs = exports.mockfilterAddressFromToLogs = exports.filterAll = exports.WETH_ADDRESS = exports.filterAddressTopics = exports.RARELAND_ADDRESS = exports.filterAddressFromTo = exports.STRONGBLOCK_ADDRESS = void 0;
+// Block(s) are 14809329
+exports.STRONGBLOCK_ADDRESS = '0xfbddadd80fe7bda00b901fbaf73803f2238ae655';
+exports.filterAddressFromTo = {
+    address: exports.STRONGBLOCK_ADDRESS,
+    fromBlock: '0xE1F8F1',
+    toBlock: '0xE1F8F1',
+};
+// Example logs that should be returned
+// https://etherscan.io/address/0x596a0f276ee432d8a28441e55737ff55cf30d0f7#events
+exports.RARELAND_ADDRESS = '0x596a0f276ee432d8a28441e55737ff55cf30d0f7';
+exports.filterAddressTopics = {
+    address: exports.RARELAND_ADDRESS,
+    topics: [
+        '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
+    ],
+};
+// https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#events
+// Address is for Wrapped Ether Contract
+exports.WETH_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
+exports.filterAll = {
+    address: exports.WETH_ADDRESS,
+    topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
+    ],
+    fromBlock: 14825027,
+    toBlock: 14825039,
+};
+exports.mockfilterAddressFromToLogs = [
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x00000000000000000000000028c2e3e17f8c61a9b7515f7bb1e1347846588b82',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001dbaed81bf64db6d',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0x5dec3a55b87edac0af5c4a9afdd015bb04303fdf86525dd1cc4e7aa7653b6301',
+        transactionIndex: '0x29',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x88',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000c3b80d78bb52fd734c4f730dad5e190ba4ecb830',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001c277de315af8924',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xae04b63efd57852e34bdc84e257bb413f9f942288f63a131d4b7071c8ee0b896',
+        transactionIndex: '0x2f',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x95',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000f1a192063f0a2b2be0cbcb2978b13e95e7f35f6b',
+        ],
+        data: '0x00000000000000000000000000000000000000000000000018ecfa70ea275b6d',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xbdba7260507b4ca24757809ac9a23e5225e80a491475ccf89a04c1894a693c77',
+        transactionIndex: '0x30',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x97',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000c78dc12c9b04858d57a108ae948020344895e910',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000000da5142efe16e492',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xdcf29bd8a44ec89a3b53488dd60b76bd7f1c532db76f88e166f3de1ab216537e',
+        transactionIndex: '0x31',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x99',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000aaf5c3760f4a77bdf23974f98d69f9ccfd778aea',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001086ed3d87034000',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0x56130c6e8fdafd0e08411b21ce984eeb56dc61d99a91f03efc7edde748d7ad81',
+        transactionIndex: '0x35',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0xac',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0x39b0a0620bb668047ab7248973ddfd93d53dff1d4952bd2d56bbf5934edc1fd0',
+            '0x0000000000000000000000001753de22132990dd5ab35f13a5951431c8ba08ea',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000e3203b',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xf5a77d85296cc670d577d3c9a76b1fa18be77239a4cb4c05493530866d60c36f',
+        transactionIndex: '0x3a',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0xb5',
+        removed: false,
+    },
+];
+exports.mockfilterAddressTopicsLogs = [];
+exports.mockfilterAllLogs = [
+    {
+        address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        topics: [
+            '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+            '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
+            '0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45',
+        ],
+        data: '0x000000000000000000000000000000000000000000000000005f862ee352a38a',
+        blockNumber: '0xe23645',
+        transactionHash: '0xbd49031be16f8fd1775f4e0fe79b408ffd8ae9c65b2827ee47e3238e3f51f4c0',
+        transactionIndex: '0xe2',
+        blockHash: '0x8e0dfac2f704851960f866c8708b3bef2f66c0fee0329cf25ff0261b264ca6bc',
+        logIndex: '0x180',
+        removed: false,
+    },
+];
+exports.mockRpcAddressFromToResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAddressFromToLogs,
+});
+exports.mockRpcAddressTopicsResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAddressTopicsLogs,
+});
+exports.mockRpcAllResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAllLogs,
+});

package/dist/cjs/providers/test/mock-of.js

@@ -1,14 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockOf = void 0;
 /**
  * Helper function for mocking other functions.
  *
- * Import it using this:
- * ```ts
- * import { mockOf } from '@earnifi/shared/src/utils/testing/mock-of';
- * ```
- *
  * @param fn
  * @example mockOf(stripe.checkout.sessions.create).mockResolvedValue(mockSession);
  * @see https://twitter.com/scastiel/status/1631354119192473601?s=20
- */ export var mockOf = function(fn) {
-    return fn;
-};
+ */
+const mockOf = (fn) => fn;
+exports.mockOf = mockOf;

package/dist/cjs/providers/test/rpc-urls.d.ts

@@ -3,6 +3,7 @@ export declare const fakeUrls: {
 };
 export declare const rpcUrls: {
     mainnet: string;
+    oeth: string;
     matic: string;
     gno: string;
     bnb: string;

package/dist/cjs/providers/test/rpc-urls.js

@@ -1,16 +1,25 @@
-import z from "zod";
-export var fakeUrls = {
-    notRPCButRealHttp: "https://httpstat.us/200"
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var RPC_ORIGIN = process.env.RPC_ORIGIN;
-if (!z.string().url().safeParse(RPC_ORIGIN).success) {
-    throw new Error("RPC_ORIGIN is not defined or is invalid URL");
-}
-export var rpcUrls = {
-    mainnet: "".concat(RPC_ORIGIN, "/api/eth"),
-    matic: "".concat(RPC_ORIGIN, "/api/MATIC"),
-    gno: "".concat(RPC_ORIGIN, "/api/gno"),
-    bnb: "".concat(RPC_ORIGIN, "/api/bnb"),
-    arb1: "".concat(RPC_ORIGIN, "/api/arb1"),
-    gor: "".concat(RPC_ORIGIN, "/api/gor")
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rpcUrls = exports.fakeUrls = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.fakeUrls = {
+    notRPCButRealHttp: 'https://httpstat.us/200',
+};
+const RPC_ORIGIN = 'https://free-eth-node.com';
+zod_1.default.string({
+    required_error: '"RPC_ORIGIN" required but not found',
+})
+    .url('Expected url for "RPC_ORIGIN"')
+    .parse(RPC_ORIGIN);
+exports.rpcUrls = {
+    mainnet: `${RPC_ORIGIN}/api/eth`,
+    oeth: `${RPC_ORIGIN}/api/oeth`,
+    matic: `${RPC_ORIGIN}/api/MATIC`,
+    gno: `${RPC_ORIGIN}/api/gno`,
+    bnb: `${RPC_ORIGIN}/api/bnb`,
+    arb1: `${RPC_ORIGIN}/api/arb1`,
+    gor: `${RPC_ORIGIN}/api/gor`,
 };