essential-eth 0.3.2 → 0.3.3

package/lib/cjs/classes/Contract.js

@@ -10,10 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Contract = exports.defineReadOnly = exports.BaseContract = void 0;
-const sha3_1 = require("sha3");
-const __1 = require("..");
+const encode_decode_transaction_1 = require("./utils/encode-decode-transaction");
 const fetchers_1 = require("./utils/fetchers");
-const hex_to_decimal_1 = require("./utils/hex-to-decimal");
 function estimateGas(txnData) {
     // https://ethereum.stackexchange.com/questions/1570/what-does-intrinsic-gas-too-low-mean/1694
     txnData.split('').reduce((previousValue, currentValue) => {
@@ -32,78 +30,33 @@ class BaseContract {
         this._contractInterface = contractInterface;
         this._provider = signerOrProvider;
         contractInterface
-            .filter((argument) => argument.type === 'function')
-            .forEach((argument) => {
-            if ('name' in argument && typeof argument.name === 'string') {
-                defineReadOnly(this, argument.name, (..._args) => __awaiter(this, void 0, void 0, function* () {
-                    let args = _args;
+            .filter((jsonABIArgument) => jsonABIArgument.type === 'function')
+            .forEach((jsonABIArgument) => {
+            if ('name' in jsonABIArgument &&
+                typeof jsonABIArgument.name === 'string') {
+                defineReadOnly(this, jsonABIArgument.name, (..._args) => __awaiter(this, void 0, void 0, function* () {
+                    let functionArguments = _args;
                     let options = {};
                     // remove options from encoding
                     const lastArg = _args[_args.length - 1];
                     if (!Array.isArray(lastArg) && typeof lastArg === 'object') {
                         options = lastArg;
-                        args = _args.slice(0, _args.length - 1);
+                        functionArguments = _args.slice(0, _args.length - 1);
                     }
-                    const hash = new sha3_1.Keccak(256);
-                    const rawOutputs = argument.outputs;
-                    /* first 4 bytes will create the data parameter */
-                    const functionString = `${argument.name}(${argument.inputs.map((input) => 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');
-                    if (args.length !== argument.inputs.length) {
-                        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${argument.inputs.length}"`);
-                    }
-                    const encodedArgs = (args || []).map((arg, i) => {
-                        let rawArg = arg;
-                        // remove leading "0x" on address types
-                        if (argument.inputs[i].type === 'address') {
-                            rawArg = arg.replace(/^0x/g, '').toLowerCase();
-                        }
-                        const argEncoded = rawArg.toString(16);
-                        const paddedEncodedArg = argEncoded.padStart(64, '0');
-                        return paddedEncodedArg;
-                    });
-                    const functionEncoded = functionHash.slice(0, 8);
-                    const myData = `0x${functionEncoded}${encodedArgs.join('')}`;
+                    const data = (0, encode_decode_transaction_1.encodeData)(jsonABIArgument, functionArguments);
                     const decimalGas = typeof options.gasLimit === 'number'
                         ? options.gasLimit /* user passed in "gasLimit" directly */
-                        : typeof (argument === null || argument === void 0 ? void 0 : argument.gas) === 'number' /* ABI specified "gas". */
-                            ? estimateGas(myData)
+                        : typeof (jsonABIArgument === null || jsonABIArgument === void 0 ? void 0 : jsonABIArgument.gas) ===
+                            'number' /* ABI specified "gas". */
+                            ? estimateGas(data)
                             : null;
                     const nodeResponse = yield (0, fetchers_1.post)(this._provider._rpcUrl, (0, fetchers_1.buildRPCPostBody)('eth_call', [
-                        Object.assign({ to: this._address.toLowerCase(), data: myData }, (decimalGas
+                        Object.assign({ to: this._address.toLowerCase(), data: data }, (decimalGas
                             ? { gas: `0x${decimalGas.toString(16)}` }
                             : {})),
                         'latest',
                     ]));
-                    // 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':
-                                switch (output) {
-                                    case '0000000000000000000000000000000000000000000000000000000000000001':
-                                        return true;
-                                    case '0000000000000000000000000000000000000000000000000000000000000000':
-                                        return false;
-                                    default:
-                                        throw new Error(`boolean response of ${output} not defined`);
-                                }
-                            case 'address':
-                                /* address types have 26 leading zeroes to remove */
-                                return (0, __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}" inputs. Make a PR today!"`);
-                        }
-                    });
-                    return outputs.length === 1 ? outputs[0] : outputs;
+                    return (0, encode_decode_transaction_1.decodeRPCResponse)(jsonABIArgument, nodeResponse);
                 }));
             }
         });

package/lib/cjs/classes/test/Contract/foo-abi.d.ts

@@ -0,0 +1,2 @@
+import { JSONABI } from '../../..';
+export declare const fooABI: JSONABI;

package/lib/cjs/classes/test/Contract/foo-abi.js

@@ -0,0 +1,42 @@
+"use strict";
+// https://docs.soliditylang.org/en/v0.6.8/abi-spec.html#examples
+// contract Foo {
+// 	function bar(bytes3[2] memory) public pure {}
+// 	function baz(uint32 x, bool y) public pure returns (bool r) { r = x > 32 || y; }
+// 	function sam(bytes memory, bool, uint[] memory) public pure {}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fooABI = void 0;
+//     }
+exports.fooABI = [
+    {
+        inputs: [
+            {
+                internalType: 'bytes3[2]',
+                name: 'memory',
+                type: 'bytes3[2]',
+            },
+        ],
+        name: 'bar',
+        outputs: [],
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'uint32', name: 'x', type: 'uint32' },
+            { internalType: 'bool', name: 'y', type: 'bool' },
+        ],
+        name: 'baz',
+        outputs: [{ internalType: 'bool', name: 'r', type: 'bool' }],
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'bytes', name: 'memory', type: 'bytes' },
+            { internalType: 'bool', name: '', type: 'bool' },
+            { internalType: 'uint[]', name: 'memory', type: 'uint[]' },
+        ],
+        name: 'sam',
+        outputs: [],
+        type: 'function',
+    },
+];

package/lib/cjs/classes/test/Contract/foo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cjs/classes/test/Contract/foo.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const encode_decode_transaction_1 = require("../../utils/encode-decode-transaction");
+const foo_abi_1 = require("./foo-abi");
+describe('foo encode', () => {
+    it('encodes "baz" function', () => {
+        const jsonABIArgument = foo_abi_1.fooABI.find((abi) => abi.name === 'baz');
+        const encoded = (0, encode_decode_transaction_1.encodeData)(jsonABIArgument, [69, true]);
+        expect(encoded).toBe('0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001');
+    });
+    it('encodes "bar" function', () => {
+        const jsonABIArgument = foo_abi_1.fooABI.find((abi) => abi.name === 'bar');
+        const encoded = (0, encode_decode_transaction_1.encodeData)(jsonABIArgument, ['abc', 'def']);
+        expect(encoded).toBe('0xfce353f661626300000000000000000000000000000000000000000000000000000000006465660000000000000000000000000000000000000000000000000000000000');
+    });
+    //   it('encodes "sam" function', () => {
+    //     const jsonABIArgument = fooABI.find(
+    //       (abi) => abi.name === 'sam',
+    //     ) as JSONABIArgument;
+    //     const encoded = encodeData(jsonABIArgument, ['dave', true, [1, 2, 3]]);
+    //     expect(encoded).toBe(
+    //       '0xa5643bf20000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000464617665000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003',
+    //     );
+    //   });
+});

package/lib/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/lib/cjs/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeRPCResponse = exports.encodeData = void 0;
+const sha3_1 = require("sha3");
+const __1 = require("../..");
+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;
+        if (inputType === 'bool') {
+            return arg ? hexTrue : hexFalse;
+        }
+        else 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;
+        }
+        // remove leading "0x" on address types
+        else if (inputType === 'address') {
+            rawArg = arg.replace(/^0x/g, '').toLowerCase();
+        }
+        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, __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}" inputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}
+exports.decodeRPCResponse = decodeRPCResponse;

package/lib/cjs/index.d.ts

@@ -1,9 +1,11 @@
+import { Transaction } from 'ethers';
 import { Contract } from './classes/Contract';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { JSONABI } from './types/Contract.types';
+import { Block } from './types/block.types';
+import { JSONABI, JSONABIArgument } from './types/Contract.types';
 import { etherToWei } from './utils/ether-to-wei';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, };
+export { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, Block, JSONABIArgument, Transaction, };

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

@@ -1,7 +1,7 @@
-export declare type ContractTypes = 'bool' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | 'string';
+export declare type ContractTypes = 'bool' | 'bytes1' | 'bytes2' | 'bytes3' | 'bytes4' | 'bytes5' | 'bytes6' | 'bytes7' | 'bytes8' | 'bytes9' | 'bytes10' | 'bytes11' | 'bytes12' | 'bytes13' | 'bytes14' | 'bytes15' | 'bytes16' | 'bytes17' | 'bytes18' | 'bytes19' | 'bytes20' | 'bytes21' | 'bytes22' | 'bytes23' | 'bytes24' | 'bytes25' | 'bytes26' | 'bytes27' | 'bytes28' | 'bytes29' | 'bytes30' | 'bytes31' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | string;
 export declare type ContractInterface = JSONABI;
 export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
-export declare type JSONABI = {
+export declare type JSONABIArgument = {
     anonymous?: false;
     inputs: {
         internalType?: ContractTypes | string;
@@ -18,4 +18,5 @@ export declare type JSONABI = {
     stateMutability?: 'view' | 'nonpayable' | string;
     type: 'function' | 'event' | 'constructor' | 'error';
     gas?: number;
-}[];
+};
+export declare type JSONABI = JSONABIArgument[];

package/lib/esm/classes/Contract.js

@@ -7,10 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Keccak } from 'sha3';
-import { tinyBig, toChecksumAddress } from '..';
+import { decodeRPCResponse, encodeData, } from './utils/encode-decode-transaction';
 import { buildRPCPostBody, post } from './utils/fetchers';
-import { hexToDecimal } from './utils/hex-to-decimal';
 function estimateGas(txnData) {
     txnData.split('').reduce((previousValue, currentValue) => {
         const characterCost = currentValue === '0' ? 4 : 68;
@@ -23,72 +21,32 @@ export class BaseContract {
         this._contractInterface = contractInterface;
         this._provider = signerOrProvider;
         contractInterface
-            .filter((argument) => argument.type === 'function')
-            .forEach((argument) => {
-            if ('name' in argument && typeof argument.name === 'string') {
-                defineReadOnly(this, argument.name, (..._args) => __awaiter(this, void 0, void 0, function* () {
-                    let args = _args;
+            .filter((jsonABIArgument) => jsonABIArgument.type === 'function')
+            .forEach((jsonABIArgument) => {
+            if ('name' in jsonABIArgument &&
+                typeof jsonABIArgument.name === 'string') {
+                defineReadOnly(this, jsonABIArgument.name, (..._args) => __awaiter(this, void 0, void 0, function* () {
+                    let functionArguments = _args;
                     let options = {};
                     const lastArg = _args[_args.length - 1];
                     if (!Array.isArray(lastArg) && typeof lastArg === 'object') {
                         options = lastArg;
-                        args = _args.slice(0, _args.length - 1);
+                        functionArguments = _args.slice(0, _args.length - 1);
                     }
-                    const hash = new Keccak(256);
-                    const rawOutputs = argument.outputs;
-                    const functionString = `${argument.name}(${argument.inputs.map((input) => input.type)})`;
-                    const functionHash = hash.update(functionString).digest('hex');
-                    if (args.length !== argument.inputs.length) {
-                        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${argument.inputs.length}"`);
-                    }
-                    const encodedArgs = (args || []).map((arg, i) => {
-                        let rawArg = arg;
-                        if (argument.inputs[i].type === 'address') {
-                            rawArg = arg.replace(/^0x/g, '').toLowerCase();
-                        }
-                        const argEncoded = rawArg.toString(16);
-                        const paddedEncodedArg = argEncoded.padStart(64, '0');
-                        return paddedEncodedArg;
-                    });
-                    const functionEncoded = functionHash.slice(0, 8);
-                    const myData = `0x${functionEncoded}${encodedArgs.join('')}`;
+                    const data = encodeData(jsonABIArgument, functionArguments);
                     const decimalGas = typeof options.gasLimit === 'number'
                         ? options.gasLimit
-                        : typeof (argument === null || argument === void 0 ? void 0 : argument.gas) === 'number'
-                            ? estimateGas(myData)
+                        : typeof (jsonABIArgument === null || jsonABIArgument === void 0 ? void 0 : jsonABIArgument.gas) ===
+                            'number'
+                            ? estimateGas(data)
                             : null;
                     const nodeResponse = yield post(this._provider._rpcUrl, buildRPCPostBody('eth_call', [
-                        Object.assign({ to: this._address.toLowerCase(), data: myData }, (decimalGas
+                        Object.assign({ to: this._address.toLowerCase(), data: data }, (decimalGas
                             ? { gas: `0x${decimalGas.toString(16)}` }
                             : {})),
                         'latest',
                     ]));
-                    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
-                    const outputs = (encodedOutputs || []).map((output, i) => {
-                        const outputType = (rawOutputs || [])[i].type;
-                        switch (outputType) {
-                            case 'bool':
-                                switch (output) {
-                                    case '0000000000000000000000000000000000000000000000000000000000000001':
-                                        return true;
-                                    case '0000000000000000000000000000000000000000000000000000000000000000':
-                                        return false;
-                                    default:
-                                        throw new Error(`boolean response of ${output} not defined`);
-                                }
-                            case 'address':
-                                return toChecksumAddress(`0x${output.slice(24)}`);
-                            case 'uint256':
-                                return tinyBig(hexToDecimal(`0x${output}`));
-                            case 'bytes32':
-                                return `0x${output}`;
-                            case 'uint8':
-                                return Number(hexToDecimal(`0x${output}`));
-                            default:
-                                throw new Error(`essential-eth does not yet support "${outputType}" inputs. Make a PR today!"`);
-                        }
-                    });
-                    return outputs.length === 1 ? outputs[0] : outputs;
+                    return decodeRPCResponse(jsonABIArgument, nodeResponse);
                 }));
             }
         });

package/lib/esm/classes/test/Contract/foo-abi.d.ts

@@ -0,0 +1,2 @@
+import { JSONABI } from '../../..';
+export declare const fooABI: JSONABI;

package/lib/esm/classes/test/Contract/foo-abi.js

@@ -0,0 +1,33 @@
+export const fooABI = [
+    {
+        inputs: [
+            {
+                internalType: 'bytes3[2]',
+                name: 'memory',
+                type: 'bytes3[2]',
+            },
+        ],
+        name: 'bar',
+        outputs: [],
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'uint32', name: 'x', type: 'uint32' },
+            { internalType: 'bool', name: 'y', type: 'bool' },
+        ],
+        name: 'baz',
+        outputs: [{ internalType: 'bool', name: 'r', type: 'bool' }],
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'bytes', name: 'memory', type: 'bytes' },
+            { internalType: 'bool', name: '', type: 'bool' },
+            { internalType: 'uint[]', name: 'memory', type: 'uint[]' },
+        ],
+        name: 'sam',
+        outputs: [],
+        type: 'function',
+    },
+];

package/lib/esm/classes/test/Contract/foo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/classes/test/Contract/foo.test.js

@@ -0,0 +1,14 @@
+import { encodeData } from '../../utils/encode-decode-transaction';
+import { fooABI } from './foo-abi';
+describe('foo encode', () => {
+    it('encodes "baz" function', () => {
+        const jsonABIArgument = fooABI.find((abi) => abi.name === 'baz');
+        const encoded = encodeData(jsonABIArgument, [69, true]);
+        expect(encoded).toBe('0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001');
+    });
+    it('encodes "bar" function', () => {
+        const jsonABIArgument = fooABI.find((abi) => abi.name === 'bar');
+        const encoded = encodeData(jsonABIArgument, ['abc', 'def']);
+        expect(encoded).toBe('0xfce353f661626300000000000000000000000000000000000000000000000000000000006465660000000000000000000000000000000000000000000000000000000000');
+    });
+});

package/lib/esm/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/lib/esm/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,85 @@
+import { Keccak } from 'sha3';
+import { tinyBig, toChecksumAddress } from '../..';
+import { hexToDecimal } from './hex-to-decimal';
+const hexTrue = '0000000000000000000000000000000000000000000000000000000000000001';
+const hexFalse = '0000000000000000000000000000000000000000000000000000000000000000';
+function expandType(type) {
+    if (type === 'uint[]') {
+        return 'uint256[]';
+    }
+    else if (type === 'int[]') {
+        return 'int256[]';
+    }
+    return type;
+}
+export function encodeData(jsonABIArgument, args) {
+    const hash = new Keccak(256);
+    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
+    const functionHash = hash.update(functionString).digest('hex');
+    const jsonABIInputsLength = jsonABIArgument.inputs.length;
+    let shouldValidateInputLength = true;
+    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('[')) {
+            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;
+        if (inputType === 'bool') {
+            return arg ? hexTrue : hexFalse;
+        }
+        else if (inputType.startsWith('bytes')) {
+            const argEncoded = rawArg
+                .split('')
+                .map((character) => character.charCodeAt(0).toString(16))
+                .join('');
+            const paddedEncodedArg = argEncoded.padEnd(64, '0');
+            return paddedEncodedArg;
+        }
+        else if (inputType === 'address') {
+            rawArg = arg.replace(/^0x/g, '').toLowerCase();
+        }
+        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;
+}
+export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    const rawOutputs = jsonABIArgument.outputs;
+    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':
+                return toChecksumAddress(`0x${output.slice(24)}`);
+            case 'uint256':
+                return tinyBig(hexToDecimal(`0x${output}`));
+            case 'bytes32':
+                return `0x${output}`;
+            case 'uint8':
+                return Number(hexToDecimal(`0x${output}`));
+            default:
+                throw new Error(`essential-eth does not yet support "${outputType}" inputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}

package/lib/esm/index.d.ts

@@ -1,9 +1,11 @@
+import { Transaction } from 'ethers';
 import { Contract } from './classes/Contract';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { JSONABI } from './types/Contract.types';
+import { Block } from './types/block.types';
+import { JSONABI, JSONABIArgument } from './types/Contract.types';
 import { etherToWei } from './utils/ether-to-wei';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, };
+export { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, Block, JSONABIArgument, Transaction, };

package/lib/esm/types/Contract.types.d.ts

@@ -1,7 +1,7 @@
-export declare type ContractTypes = 'bool' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | 'string';
+export declare type ContractTypes = 'bool' | 'bytes1' | 'bytes2' | 'bytes3' | 'bytes4' | 'bytes5' | 'bytes6' | 'bytes7' | 'bytes8' | 'bytes9' | 'bytes10' | 'bytes11' | 'bytes12' | 'bytes13' | 'bytes14' | 'bytes15' | 'bytes16' | 'bytes17' | 'bytes18' | 'bytes19' | 'bytes20' | 'bytes21' | 'bytes22' | 'bytes23' | 'bytes24' | 'bytes25' | 'bytes26' | 'bytes27' | 'bytes28' | 'bytes29' | 'bytes30' | 'bytes31' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | string;
 export declare type ContractInterface = JSONABI;
 export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
-export declare type JSONABI = {
+export declare type JSONABIArgument = {
     anonymous?: false;
     inputs: {
         internalType?: ContractTypes | string;
@@ -18,4 +18,5 @@ export declare type JSONABI = {
     stateMutability?: 'view' | 'nonpayable' | string;
     type: 'function' | 'event' | 'constructor' | 'error';
     gas?: number;
-}[];
+};
+export declare type JSONABI = JSONABIArgument[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "essential-eth",
   "description": "Ultralight JS library for Ethereum utilities",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",