essential-eth 0.4.9-beta.4 → 0.4.11

package/lib/cjs/shared/tiny-big/tiny-big.d.ts

@@ -15,5 +15,11 @@ export declare class TinyBig extends Big {
 }
 /**
  * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ *
+ * @example
+ * ```javascript
+ * tinyBig(10).times(3).toNumber()
+ * // 30
+ * ```
  */
 export declare function tinyBig(value: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/shared/tiny-big/tiny-big.js

@@ -34,6 +34,12 @@ class TinyBig extends big_js_1.default {
 exports.TinyBig = TinyBig;
 /**
  * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ *
+ * @example
+ * ```javascript
+ * tinyBig(10).times(3).toNumber()
+ * // 30
+ * ```
  */
 function tinyBig(value) {
     return new TinyBig(value);

package/lib/cjs/types/Block.types.d.ts

@@ -45,3 +45,4 @@ export interface RPCBlock {
     transactionsRoot: string;
     uncles: unknown[];
 }
+export declare type BlockTag = 'latest' | 'earliest' | 'pending' | number | string;

package/lib/cjs/utils/ether-to-gwei.d.ts

@@ -0,0 +1,26 @@
+import Big from 'big.js';
+import { TinyBig } from '../shared/tiny-big/tiny-big';
+/**
+ * Convert from Ether to Gwei
+ *
+ * No direct equivalent in ether.js; requires multiple functions to achieve.
+ *
+ * No direct equivalent in web3; requires multiple functions to achieve.
+ *
+ * @example
+ * ```javascript
+ * etherToGwei('1000').toString()
+ * // '1000000000000'
+ * etherToGwei(1000).toString()
+ * // '1000000000000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * etherToGwei('1000').toNumber()
+ * // 1000000000000
+ * etherToGwei(1000).toNumber()
+ * // 1000000000000
+ * ```
+ */
+export declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/ether-to-gwei.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etherToGwei = void 0;
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Convert from Ether to Gwei
+ *
+ * No direct equivalent in ether.js; requires multiple functions to achieve.
+ *
+ * No direct equivalent in web3; requires multiple functions to achieve.
+ *
+ * @example
+ * ```javascript
+ * etherToGwei('1000').toString()
+ * // '1000000000000'
+ * etherToGwei(1000).toString()
+ * // '1000000000000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * etherToGwei('1000').toNumber()
+ * // 1000000000000
+ * etherToGwei(1000).toNumber()
+ * // 1000000000000
+ * ```
+ */
+function etherToGwei(etherQuantity) {
+    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number', 'object']);
+    const result = (0, tiny_big_1.tinyBig)(etherQuantity).times('1000000000');
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.etherToGwei = etherToGwei;

package/lib/cjs/utils/ether-to-wei.d.ts

@@ -1,9 +1,11 @@
 import Big from 'big.js';
 import { TinyBig } from '../shared/tiny-big/tiny-big';
 /**
- * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ * Convert Ether to Wei
  *
- * Similar to ["toWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html?highlight=towei#towei)
+ * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-parseEther)
+ *
+ * Similar to ["toWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#towei)
  *
  * @example
  * ```javascript

package/lib/cjs/utils/ether-to-wei.js

@@ -4,9 +4,11 @@ exports.etherToWei = void 0;
 const tiny_big_1 = require("../shared/tiny-big/tiny-big");
 const validate_type_1 = require("../shared/validate-type");
 /**
- * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ * Convert Ether to Wei
  *
- * Similar to ["toWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html?highlight=towei#towei)
+ * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-parseEther)
+ *
+ * Similar to ["toWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#towei)
  *
  * @example
  * ```javascript

package/lib/cjs/utils/gwei-to-ether.d.ts

@@ -0,0 +1,26 @@
+import Big from 'big.js';
+import { TinyBig } from './../shared/tiny-big/tiny-big';
+/**
+ * Convert from Gwei to Ether
+ *
+ * No direct equivalent in ethers.js; requires multiple functions to achieve.
+ *
+ * No direct equivalent in web3; requires multiple functions to achieve.
+ *
+ * @example
+ * ```javascript
+ * gweiToEther('1000000000000').toString()
+ * // '1000'
+ * gweiToEther(1000000000000).toString()
+ * // '1000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * gweiToEther('1000000000000').toNumber()
+ * // 1000
+ * gweiToEther(1000000000000).toNumber()
+ * // 1000
+ * ```
+ */
+export declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/gwei-to-ether.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gweiToEther = void 0;
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Convert from Gwei to Ether
+ *
+ * No direct equivalent in ethers.js; requires multiple functions to achieve.
+ *
+ * No direct equivalent in web3; requires multiple functions to achieve.
+ *
+ * @example
+ * ```javascript
+ * gweiToEther('1000000000000').toString()
+ * // '1000'
+ * gweiToEther(1000000000000).toString()
+ * // '1000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * gweiToEther('1000000000000').toNumber()
+ * // 1000
+ * gweiToEther(1000000000000).toNumber()
+ * // 1000
+ * ```
+ */
+function gweiToEther(gweiQuantity) {
+    (0, validate_type_1.validateType)(gweiQuantity, ['string', 'number', 'object']);
+    const result = (0, tiny_big_1.tinyBig)(gweiQuantity).div('1000000000');
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.gweiToEther = gweiToEther;

package/lib/cjs/utils/is-address.d.ts

@@ -1,5 +1,24 @@
 /**
  * Returns a boolean as to whether the input is a valid address.
  * Does NOT support ICAP addresses
+ *
+ * @example
+ * ```javascript
+ * isAddress('0xc0deaf6bd3f0c6574a6a625ef2f22f62a5150eab');
+ * // true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * isAddress('bad');
+ * // false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Does NOT support ENS.
+ * isAddress('vitalik.eth');
+ * // false
+ * ```
  */
 export declare function isAddress(address: string): boolean;

package/lib/cjs/utils/is-address.js

@@ -6,6 +6,25 @@ const validate_type_1 = require("../shared/validate-type");
 /**
  * Returns a boolean as to whether the input is a valid address.
  * Does NOT support ICAP addresses
+ *
+ * @example
+ * ```javascript
+ * isAddress('0xc0deaf6bd3f0c6574a6a625ef2f22f62a5150eab');
+ * // true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * isAddress('bad');
+ * // false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Does NOT support ENS.
+ * isAddress('vitalik.eth');
+ * // false
+ * ```
  */
 function isAddress(address) {
     (0, validate_type_1.validateType)(address, ['string']);

package/lib/cjs/utils/to-checksum-address.d.ts

@@ -10,8 +10,8 @@
  * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
  * ```
  *
- * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v4/api-utils.html#utils-getaddress)
+ * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v5/api/utils/address/#utils-getAddress)
  *
- * Similar to ["toChecksumAddress" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#tochecksumaddress)
+ * Similar to ["toChecksumAddress" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#tochecksumaddress)
  */
 export declare function toChecksumAddress(address: string): string;

package/lib/cjs/utils/to-checksum-address.js

@@ -15,9 +15,9 @@ const validate_type_1 = require("../shared/validate-type");
  * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
  * ```
  *
- * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v4/api-utils.html#utils-getaddress)
+ * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v5/api/utils/address/#utils-getAddress)
  *
- * Similar to ["toChecksumAddress" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#tochecksumaddress)
+ * Similar to ["toChecksumAddress" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#tochecksumaddress)
  */
 function toChecksumAddress(address) {
     (0, validate_type_1.validateType)(address, ['string']);

package/lib/cjs/utils/wei-to-ether.d.ts

@@ -1,26 +1,26 @@
 import Big from 'big.js';
-import { TinyBig } from './../shared/tiny-big/tiny-big';
+import { TinyBig } from '../shared/tiny-big/tiny-big';
 /**
- * Convert from Ether to Wei
+ * Convert from Wei to Ether
  *
- * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-formatEther)
  *
- * Similar to ["fromWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#fromwei)
+ * Similar to ["fromWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#fromwei)
  *
  * @example
  * ```javascript
- * etherToWei('1000').toString()
- * // '1000000000000000000000'
- * etherToWei(1000).toString()
- * '1000000000000000000000'
+ * weiToEther('1000000000000000000000').toString()
+ * // '1000'
+ * weiToEther(1000000000000000000000).toString()
+ * // '1000'
  * ```
  *
  * @example
  * ```javascript
- * etherToWei('1000').toNumber()
- * // 1000000000000000000000
- * etherToWei(1000).toNumber()
- * // 1000000000000000000000
+ * weiToEther('1000000000000000000000').toNumber()
+ * // 1000
+ * weiToEther(1000000000000000000000).toNumber()
+ * // 1000
  * ```
  */
 export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/wei-to-ether.js

@@ -4,26 +4,26 @@ exports.weiToEther = void 0;
 const tiny_big_1 = require("../shared/tiny-big/tiny-big");
 const validate_type_1 = require("../shared/validate-type");
 /**
- * Convert from Ether to Wei
+ * Convert from Wei to Ether
  *
- * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-formatEther)
  *
- * Similar to ["fromWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#fromwei)
+ * Similar to ["fromWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#fromwei)
  *
  * @example
  * ```javascript
- * etherToWei('1000').toString()
- * // '1000000000000000000000'
- * etherToWei(1000).toString()
- * '1000000000000000000000'
+ * weiToEther('1000000000000000000000').toString()
+ * // '1000'
+ * weiToEther(1000000000000000000000).toString()
+ * // '1000'
  * ```
  *
  * @example
  * ```javascript
- * etherToWei('1000').toNumber()
- * // 1000000000000000000000
- * etherToWei(1000).toNumber()
- * // 1000000000000000000000
+ * weiToEther('1000000000000000000000').toNumber()
+ * // 1000
+ * weiToEther(1000000000000000000000).toNumber()
+ * // 1000
  * ```
  */
 function weiToEther(weiQuantity) {

package/lib/esm/classes/Contract.js

@@ -40,17 +40,12 @@ export class BaseContract {
                             ? estimateGas(data)
                             : null;
                     const req = () => __awaiter(this, void 0, void 0, function* () {
-                        return yield post(this._provider._rpcUrl[this._provider._rpcUrlCounter], buildRPCPostBody('eth_call', [
-                            Object.assign({ to: this._address.toLowerCase(), data: data }, (decimalGas
+                        return yield post(this._provider._rpcUrl, buildRPCPostBody('eth_call', [
+                            Object.assign({ to: this._address.toLowerCase(), data }, (decimalGas
                                 ? { gas: `0x${decimalGas.toString(16)}` }
                                 : {})),
                             'latest',
-                        ])).catch((e) => {
-                            if (e.code === 'ENOTFOUND') {
-                                this._provider._rpcUrlCounter++;
-                                return req();
-                            }
-                        });
+                        ]));
                     });
                     const nodeResponse = yield req();
                     return decodeRPCResponse(jsonABIArgument, nodeResponse);

package/lib/esm/classes/utils/fetchers.d.ts

@@ -1,9 +1,9 @@
 export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
-declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_call' | 'eth_chainId';
-export declare function buildRPCPostBody(method: RPCMethodName, params: any[]): {
+declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_call' | 'eth_chainId' | 'eth_gasPrice' | 'eth_getBalance';
+export declare function buildRPCPostBody(method: RPCMethodName, params: unknown[]): {
     jsonrpc: string;
     id: number;
     method: RPCMethodName;
-    params: any[];
+    params: unknown[];
 };
 export {};

package/lib/esm/classes/utils/fetchers.js

@@ -1,3 +1,12 @@
+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());
+    });
+};
 import unfetch from 'isomorphic-unfetch';
 export function post(url, body) {
     return unfetch(url, {
@@ -7,10 +16,19 @@ export function post(url, body) {
         },
         body: JSON.stringify(body),
     })
-        .then((r) => r.json())
+        .then((r) => __awaiter(this, void 0, void 0, function* () {
+        const t = yield r.text();
+        try {
+            return JSON.parse(t);
+        }
+        catch (_a) {
+            throw new Error(`Invalid JSON RPC response: "${t}"`);
+        }
+    }))
         .then((response) => {
-        if (response.error) {
-            throw new Error(response.error);
+        const result = response === null || response === void 0 ? void 0 : response.result;
+        if (!result) {
+            throw new Error(`Invalid JSON RPC response: ${JSON.stringify(response)}`);
         }
         return response.result;
     });

package/lib/esm/index.d.ts

@@ -5,9 +5,10 @@ import { Block } from './types/Block.types';
 import { ContractTypes, JSONABI, JSONABIArgument } from './types/Contract.types';
 import { Network } from './types/Network.types';
 import { Transaction } from './types/Transaction.types';
-import * as utils from './utils';
+import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
+import { gweiToEther } from './utils/gwei-to-ether';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { utils, etherToWei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, Contract, TinyBig, Block, ContractTypes, JSONABI, JSONABIArgument, Network, Transaction, };
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, Block, ContractTypes, JSONABI, JSONABIArgument, Network, Transaction, };

package/lib/esm/index.js

@@ -1,9 +1,10 @@
 import { Contract } from './classes/Contract';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import * as utils from './utils';
+import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
+import { gweiToEther } from './utils/gwei-to-ether';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { utils, etherToWei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, Contract, TinyBig, };
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, };

package/lib/esm/providers/JsonRpcProvider.d.ts

@@ -1,10 +1,12 @@
-import { Block } from '../types/Block.types';
+import { TinyBig } from '../shared/tiny-big/tiny-big';
+import { Block, BlockTag } from '../types/Block.types';
 import { Network } from '../types/Network.types';
 export declare class JsonRpcProvider {
-    readonly _rpcUrl: Array<string>;
-    _rpcUrlCounter: number;
-    constructor(rpcUrl?: string | Array<string>);
-    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+    readonly _rpcUrl: string;
+    constructor(rpcUrl?: string);
+    getBlock(timeFrame: BlockTag, returnTransactionObjects?: boolean): Promise<Block>;
     getNetwork(): Promise<Network>;
+    getGasPrice(): Promise<TinyBig>;
+    getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;
 }
 export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/esm/providers/JsonRpcProvider.js

@@ -10,19 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { cleanBlock } from '../classes/utils/clean-block';
 import { buildRPCPostBody, post } from '../classes/utils/fetchers';
 import { hexToDecimal } from '../classes/utils/hex-to-decimal';
+import { tinyBig } from '../shared/tiny-big/tiny-big';
 import chainsInfo from './utils/chains-info';
 export class JsonRpcProvider {
     constructor(rpcUrl) {
-        this._rpcUrl = (() => {
-            if (!rpcUrl) {
-                return ['https://free-eth-node.com/api/eth'];
-            }
-            else if (!Array.isArray(rpcUrl)) {
-                return [rpcUrl];
-            }
-            return rpcUrl;
-        })();
-        this._rpcUrlCounter = 0;
+        this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
     }
     getBlock(timeFrame, returnTransactionObjects = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -33,31 +25,21 @@ export class JsonRpcProvider {
             else {
                 rpcTimeFrame = timeFrame;
             }
-            const req = () => __awaiter(this, void 0, void 0, function* () {
-                return yield post(this._rpcUrl[this._rpcUrlCounter], buildRPCPostBody('eth_getBlockByNumber', [
+            const req = () => {
+                return post(this._rpcUrl, buildRPCPostBody('eth_getBlockByNumber', [
                     rpcTimeFrame,
                     returnTransactionObjects,
-                ])).catch((e) => {
-                    if (e.code === 'ENOTFOUND') {
-                        this._rpcUrlCounter++;
-                        return req();
-                    }
-                });
-            });
+                ]));
+            };
             const nodeResponse = (yield req());
             return cleanBlock(nodeResponse, returnTransactionObjects);
         });
     }
     getNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = () => __awaiter(this, void 0, void 0, function* () {
-                return yield post(this._rpcUrl[this._rpcUrlCounter], buildRPCPostBody('eth_chainId', [])).catch((e) => {
-                    if (e.code === 'ENOTFOUND') {
-                        this._rpcUrlCounter++;
-                        return req();
-                    }
-                });
-            });
+            const req = () => {
+                return post(this._rpcUrl, buildRPCPostBody('eth_chainId', []));
+            };
             const nodeResponse = (yield req());
             const chainId = hexToDecimal(nodeResponse);
             const info = chainsInfo[chainId];
@@ -68,6 +50,24 @@ export class JsonRpcProvider {
             };
         });
     }
+    getGasPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = () => {
+                return post(this._rpcUrl, buildRPCPostBody('eth_gasPrice', []));
+            };
+            const nodeResponse = (yield req());
+            return tinyBig(hexToDecimal(nodeResponse));
+        });
+    }
+    getBalance(address, blockTag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = () => {
+                return post(this._rpcUrl, buildRPCPostBody('eth_getBalance', [address, blockTag]));
+            };
+            const nodeResponse = (yield req());
+            return tinyBig(hexToDecimal(nodeResponse));
+        });
+    }
 }
 export function jsonRpcProvider(rpcUrl) {
     return new JsonRpcProvider(rpcUrl);

package/lib/esm/providers/test/rpc-urls.d.ts

@@ -0,0 +1,10 @@
+export declare const fakeUrls: {
+    readonly notRPCButRealHttp: "https://httpstat.us/200";
+};
+export declare const rpcUrls: {
+    mainnet: string;
+    gno: string;
+    bnb: string;
+    arb1: string;
+    gor: string;
+};

package/lib/esm/providers/test/rpc-urls.js

@@ -0,0 +1,10 @@
+export const fakeUrls = {
+    notRPCButRealHttp: 'https://httpstat.us/200',
+};
+export const rpcUrls = {
+    mainnet: `${process.env.RPC_ORIGIN}/api/eth`,
+    gno: `${process.env.RPC_ORIGIN}/api/gno`,
+    bnb: `${process.env.RPC_ORIGIN}/api/bnb`,
+    arb1: `${process.env.RPC_ORIGIN}/api/arb1`,
+    gor: `${process.env.RPC_ORIGIN}/api/gor`,
+};