essential-eth 0.4.9-beta.0 → 0.4.9-beta.3

package/dist/cjs/classes/utils/clean-block.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanBlock = void 0;
+const utils_1 = require("../../utils");
+const clean_transaction_1 = require("./clean-transaction");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+/**
+ * Converts hex to decimal and checksum-addresses all addresses
+ */
+function cleanBlock(block, returnTransactionObjects) {
+    const cleanedBlock = Object.assign({}, block);
+    Object.keys(block).forEach((key) => {
+        // pending blocks have null instead of a difficulty
+        // pending blocks have null instead of a miner address
+        if (!block[key])
+            return;
+        switch (key) {
+            case 'gasLimit':
+            case 'gasUsed':
+            case 'number':
+            case 'size':
+            case 'timestamp':
+            case 'baseFeePerGas':
+                cleanedBlock[key] = Number((0, hex_to_decimal_1.hexToDecimal)(block[key]));
+                break;
+            case 'difficulty':
+            case 'totalDifficulty':
+                cleanedBlock[key] = (0, hex_to_decimal_1.hexToDecimal)(block[key]);
+                break;
+            case 'miner':
+                if (block[key]) {
+                    cleanedBlock[key] = (0, utils_1.toChecksumAddress)(block[key]);
+                }
+                break;
+        }
+    });
+    // for all full transactions
+    if (returnTransactionObjects) {
+        // could be renamed "cleanTransaction" in the future
+        cleanedBlock.transactions.forEach((transaction, index) => {
+            cleanedBlock.transactions[index] = (0, clean_transaction_1.cleanTransaction)(transaction);
+        });
+    }
+    return cleanedBlock;
+}
+exports.cleanBlock = cleanBlock;

package/dist/cjs/classes/utils/clean-transaction.d.ts

@@ -0,0 +1,5 @@
+import { RPCTransaction, Transaction } from '../../types/Transaction.types';
+/**
+ * Converts hex to decimal and checksum-addresses all addresses
+ */
+export declare function cleanTransaction(transaction: RPCTransaction): Transaction;

package/dist/cjs/classes/utils/clean-transaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanTransaction = void 0;
+const utils_1 = require("../../utils");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+/**
+ * Converts hex to decimal and checksum-addresses all addresses
+ */
+function cleanTransaction(transaction) {
+    const cleanedTransaction = Object.assign({}, transaction);
+    Object.keys(transaction).forEach((key) => {
+        // pending blocks have null instead of a difficulty
+        // pending blocks have null instead of a miner address
+        if (!transaction[key])
+            return;
+        switch (key) {
+            case 'blockNumber':
+            case 'gas':
+            case 'nonce':
+            case 'transactionIndex':
+            case 'type':
+                cleanedTransaction[key] = Number((0, hex_to_decimal_1.hexToDecimal)(transaction[key]));
+                break;
+            case 'gasPrice':
+            case 'value':
+                cleanedTransaction[key] = (0, hex_to_decimal_1.hexToDecimal)(transaction[key]);
+                break;
+            case 'from':
+            case 'to':
+                if (transaction[key]) {
+                    cleanedTransaction[key] = (0, utils_1.toChecksumAddress)(transaction[key]);
+                }
+                break;
+        }
+    });
+    return cleanedTransaction;
+}
+exports.cleanTransaction = cleanTransaction;

package/dist/cjs/classes/utils/encode-decode-transaction.d.ts

@@ -0,0 +1,3 @@
+import { JSONABIArgument } from '../../types/Contract.types';
+export declare function encodeData(jsonABIArgument: JSONABIArgument, args: any[]): string;
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../..").TinyBig | (string | number | boolean | import("../..").TinyBig)[];

package/dist/cjs/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeRPCResponse = exports.encodeData = void 0;
+const sha3_1 = require("sha3");
+const __1 = require("../..");
+const utils_1 = require("../../utils");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+const hexTrue = '0000000000000000000000000000000000000000000000000000000000000001';
+const hexFalse = '0000000000000000000000000000000000000000000000000000000000000000';
+function expandType(type) {
+    // https://docs.soliditylang.org/en/v0.8.7/types.html#integers
+    if (type === 'uint[]') {
+        return 'uint256[]';
+    }
+    else if (type === 'int[]') {
+        return 'int256[]';
+    }
+    return type;
+}
+function encodeData(jsonABIArgument, args) {
+    const hash = new sha3_1.Keccak(256);
+    /* first 4 bytes will create the data parameter */
+    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
+    // encoding learnt from https://ethereum.stackexchange.com/questions/3514/how-to-call-a-contract-method-using-the-eth-call-json-rpc-api
+    const functionHash = hash.update(functionString).digest('hex');
+    // no arrays
+    const jsonABIInputsLength = jsonABIArgument.inputs.length;
+    let shouldValidateInputLength = true;
+    // inputs contains 1 or more arrays
+    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+        shouldValidateInputLength = false;
+    }
+    if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
+        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`);
+    }
+    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
+        var _a;
+        if (input.type.includes('[')) {
+            // strip array and length like "[2]" from type
+            const basicType = (_a = /([^[]*)\[.*$/g.exec(input.type)) === null || _a === void 0 ? void 0 : _a[1];
+            args.forEach((arg) => {
+                acc = acc.concat([[arg, basicType]]);
+            });
+            return acc;
+        }
+        else {
+            return acc.concat([[args[i], input.type]]);
+        }
+    }, []);
+    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
+        let rawArg = arg;
+        switch (inputType) {
+            case 'bool':
+                return arg ? hexTrue : hexFalse;
+            case 'address':
+                // remove leading "0x"
+                rawArg = arg.replace(/^0x/g, '').toLowerCase();
+                break;
+            default:
+                if (inputType.startsWith('bytes')) {
+                    // encode each character to hex
+                    const argEncoded = rawArg
+                        .split('')
+                        .map((character) => character.charCodeAt(0).toString(16))
+                        .join('');
+                    const paddedEncodedArg = argEncoded.padEnd(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType === 'uint256') {
+                    const argEncoded = BigInt(arg).toString(16);
+                    const paddedEncodedArg = argEncoded.padStart(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType.startsWith('uint')) {
+                    break;
+                }
+                else {
+                    throw new Error(`essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`);
+                }
+        }
+        const argEncoded = rawArg.toString(16);
+        const paddedEncodedArg = argEncoded.padStart(64, '0');
+        return paddedEncodedArg;
+    });
+    const functionEncoded = functionHash.slice(0, 8);
+    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+    return data;
+}
+exports.encodeData = encodeData;
+function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    const rawOutputs = jsonABIArgument.outputs;
+    // chunk response every 64 characters
+    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+    const outputs = (encodedOutputs || []).map((output, i) => {
+        const outputType = (rawOutputs || [])[i].type;
+        switch (outputType) {
+            case 'bool':
+                return output === hexTrue;
+            case 'address':
+                /* address types have 26 leading zeroes to remove */
+                return (0, utils_1.toChecksumAddress)(`0x${output.slice(24)}`);
+            case 'uint256':
+                return (0, __1.tinyBig)((0, hex_to_decimal_1.hexToDecimal)(`0x${output}`));
+            case 'bytes32':
+                return `0x${output}`;
+            case 'uint8':
+                return Number((0, hex_to_decimal_1.hexToDecimal)(`0x${output}`));
+            default:
+                throw new Error(`essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}
+exports.decodeRPCResponse = decodeRPCResponse;

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

@@ -0,0 +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[]): {
+    jsonrpc: string;
+    id: number;
+    method: RPCMethodName;
+    params: any[];
+};
+export {};

package/dist/cjs/classes/utils/fetchers.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRPCPostBody = exports.post = void 0;
+const isomorphic_unfetch_1 = __importDefault(require("isomorphic-unfetch"));
+function post(url, body) {
+    return (0, isomorphic_unfetch_1.default)(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    })
+        .then((r) => r.json())
+        .then((response) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return response.result;
+    });
+}
+exports.post = post;
+function buildRPCPostBody(method, params) {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    };
+}
+exports.buildRPCPostBody = buildRPCPostBody;

package/{src/classes/utils/hex-to-decimal.ts → dist/cjs/classes/utils/hex-to-decimal.d.ts}

@@ -2,6 +2,4 @@
  * Converts a hexadecimal string it's decimal equivalent.
  * This is needed instead of parseInt because parseInt loses precision
  */
-export function hexToDecimal(hex: string) {
-  return BigInt(hex).toString();
-}
+export declare function hexToDecimal(hex: string): string;

package/dist/cjs/classes/utils/hex-to-decimal.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToDecimal = void 0;
+/**
+ * Converts a hexadecimal string it's decimal equivalent.
+ * This is needed instead of parseInt because parseInt loses precision
+ */
+function hexToDecimal(hex) {
+    return BigInt(hex).toString();
+}
+exports.hexToDecimal = hexToDecimal;

package/{src/index.ts → dist/cjs/index.d.ts}

@@ -2,26 +2,8 @@ import { Contract } from './classes/Contract';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
 import { Block } from './types/Block.types';
-import {
-  ContractTypes,
-  JSONABI,
-  JSONABIArgument,
-} from './types/Contract.types';
+import { ContractTypes, JSONABI, JSONABIArgument } from './types/Contract.types';
 import { Network } from './types/Network.types';
 import { Transaction } from './types/Transaction.types';
-export * from './utils';
-export {
-  jsonRpcProvider,
-  JsonRpcProvider,
-  tinyBig,
-  /* classes */
-  Contract,
-  TinyBig,
-  /* types */
-  Block,
-  ContractTypes,
-  JSONABI,
-  JSONABIArgument,
-  Network,
-  Transaction,
-};
+import * as utils from './utils';
+export { utils, jsonRpcProvider, JsonRpcProvider, tinyBig, Contract, TinyBig, Block, ContractTypes, JSONABI, JSONABIArgument, Network, Transaction, };

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TinyBig = exports.Contract = exports.tinyBig = exports.JsonRpcProvider = exports.jsonRpcProvider = exports.utils = void 0;
+const Contract_1 = require("./classes/Contract");
+Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return Contract_1.Contract; } });
+const JsonRpcProvider_1 = require("./providers/JsonRpcProvider");
+Object.defineProperty(exports, "JsonRpcProvider", { enumerable: true, get: function () { return JsonRpcProvider_1.JsonRpcProvider; } });
+Object.defineProperty(exports, "jsonRpcProvider", { enumerable: true, get: function () { return JsonRpcProvider_1.jsonRpcProvider; } });
+const tiny_big_1 = require("./shared/tiny-big/tiny-big");
+Object.defineProperty(exports, "tinyBig", { enumerable: true, get: function () { return tiny_big_1.tinyBig; } });
+Object.defineProperty(exports, "TinyBig", { enumerable: true, get: function () { return tiny_big_1.TinyBig; } });
+const utils = __importStar(require("./utils"));
+exports.utils = utils;

package/dist/cjs/providers/JsonRpcProvider.d.ts

@@ -0,0 +1,23 @@
+import { Block } from '../types/Block.types';
+import { Network } from '../types/Network.types';
+export declare class JsonRpcProvider {
+    /**
+     * The URL to your Eth node. Consider POKT or Infura
+     */
+    readonly _rpcUrl: Array<string>;
+    _rpcUrlCounter: number;
+    constructor(rpcUrl?: string | Array<string>);
+    /**
+     * Returns the block requested
+     * Same as `web3.eth.getBlock`
+     */
+    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+    /**
+     * Returns the network this provider is connected to
+     */
+    getNetwork(): Promise<Network>;
+}
+/**
+ * Helper function to avoid "new"
+ */
+export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/dist/cjs/providers/JsonRpcProvider.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonRpcProvider = exports.JsonRpcProvider = void 0;
+const clean_block_1 = require("../classes/utils/clean-block");
+const fetchers_1 = require("../classes/utils/fetchers");
+const hex_to_decimal_1 = require("../classes/utils/hex-to-decimal");
+const chains_info_1 = __importDefault(require("./utils/chains-info"));
+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;
+    }
+    /**
+     * Returns the block requested
+     * Same as `web3.eth.getBlock`
+     */
+    getBlock(timeFrame /* block number as integer */, returnTransactionObjects = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rpcTimeFrame;
+            if (typeof timeFrame === 'number') {
+                // exact block numbers require hex string format
+                rpcTimeFrame = `0x${timeFrame.toString(16)}`;
+            }
+            else {
+                // "latest", "earliest", and "pending" require no manipulation
+                rpcTimeFrame = timeFrame;
+            }
+            const req = () => __awaiter(this, void 0, void 0, function* () {
+                return yield (0, fetchers_1.post)(this._rpcUrl[this._rpcUrlCounter], (0, fetchers_1.buildRPCPostBody)('eth_getBlockByNumber', [
+                    rpcTimeFrame,
+                    returnTransactionObjects,
+                ])).catch((e) => {
+                    if (e.code === 'ENOTFOUND') {
+                        this._rpcUrlCounter++;
+                        return req();
+                    }
+                });
+            });
+            const nodeResponse = (yield req());
+            return (0, clean_block_1.cleanBlock)(nodeResponse, returnTransactionObjects);
+        });
+    }
+    /**
+     * Returns the network this provider is connected to
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = () => __awaiter(this, void 0, void 0, function* () {
+                return yield (0, fetchers_1.post)(this._rpcUrl[this._rpcUrlCounter], (0, fetchers_1.buildRPCPostBody)('eth_chainId', [])).catch((e) => {
+                    if (e.code === 'ENOTFOUND') {
+                        this._rpcUrlCounter++;
+                        return req();
+                    }
+                });
+            });
+            const nodeResponse = (yield req());
+            const chainId = (0, hex_to_decimal_1.hexToDecimal)(nodeResponse);
+            const info = chains_info_1.default[chainId];
+            return {
+                chainId: Number(chainId),
+                name: info[0] || 'unknown',
+                ensAddress: info[1] || null, // only send ensAddress if it exists
+            };
+        });
+    }
+}
+exports.JsonRpcProvider = JsonRpcProvider;
+/**
+ * Helper function to avoid "new"
+ */
+function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}
+exports.jsonRpcProvider = jsonRpcProvider;