essential-eth 0.6.2 → 0.7.0

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

@@ -1,32 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanLog = void 0;
-const to_checksum_address_1 = require("../../utils/to-checksum-address");
-const hex_to_decimal_1 = require("./hex-to-decimal");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+import { toChecksumAddress } from "../../utils/to-checksum-address";
+import { hexToDecimal } from "./hex-to-decimal";
 /**
  * Converts RPC log receipt response to more JS-friendly format
  *
  * @param log the log to clean
  * @param receiptLog if the log is part of a transaction receipt. Used to remove certain keys from log
  * @example
- */
-function cleanLog(log, receiptLog) {
-    const cleanedLog = Object.assign({}, log);
-    Object.keys(log).forEach((key) => {
-        switch (key) {
-            case 'address':
-                cleanedLog[key] = (0, to_checksum_address_1.toChecksumAddress)(log[key]);
+ */ export function cleanLog(log, receiptLog) {
+    var cleanedLog = _objectSpread({}, log);
+    Object.keys(log).forEach(function(key) {
+        switch(key){
+            case "address":
+                cleanedLog[key] = toChecksumAddress(log[key]);
                 break;
-            case 'blockNumber':
-            case 'logIndex':
-            case 'transactionIndex':
-                cleanedLog[key] = Number((0, hex_to_decimal_1.hexToDecimal)(log[key]));
+            case "blockNumber":
+            case "logIndex":
+            case "transactionIndex":
+                cleanedLog[key] = Number(hexToDecimal(log[key]));
                 break;
-            case 'removed':
+            case "removed":
                 if (receiptLog) {
                     delete cleanedLog[key];
-                }
-                else if (log[key] == null) {
+                } else if (log[key] == null) {
                     cleanedLog[key] === false;
                 }
                 break;
@@ -34,4 +57,3 @@ function cleanLog(log, receiptLog) {
     });
     return cleanedLog;
 }
-exports.cleanLog = cleanLog;

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

@@ -1,10 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanTransactionReceipt = void 0;
-const __1 = require("../..");
-const clean_log_1 = require("./clean-log");
-const clean_transaction_1 = require("./clean-transaction");
-const hex_to_decimal_1 = require("./hex-to-decimal");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+import { tinyBig } from "../../shared/tiny-big/tiny-big";
+import { toChecksumAddress } from "../../utils/to-checksum-address";
+import { cleanLog } from "./clean-log";
+import { cleanTransaction } from "./clean-transaction";
+import { hexToDecimal } from "./hex-to-decimal";
 /**
  * Converts RPC transaction receipt response to more JS-friendly format
  *
@@ -16,35 +42,31 @@ const hex_to_decimal_1 = require("./hex-to-decimal");
  * cleanTransactionReceipt(RPCTransactionReceipt);
  * // { blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, contractAddress: null, cumulativeGasUsed: Big { s: 1, e: 6, c: [ 3, 6, 4, 6, 1, 3, 7 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, effectiveGasPrice: Big { s: 1, e: 10, c: [ 2, 6, 5, 4, 0, 6, 2, 3, 4, 0, 4 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, from: '0x642824FaB1D0141073ed74326332950bEc4701e3', gasUsed: Big { s: 1, e: 5, c: [ 1, 0, 7, 3, 0, 1 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, logs: [ { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 84, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x000000000000000000000000000000000000000000000000000000000000074d' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 85, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x000000000000000000000000000000000000000000000000000000000000074e' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 86, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x000000000000000000000000000000000000000000000000000000000000074f' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 87, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000750' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 88, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000751' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 89, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000752' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 90, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000753' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 91, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000754' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 92, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000755' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 }, { address: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, data: '0x', logIndex: 93, topics: [ '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', '0x0000000000000000000000000000000000000000000000000000000000000000', '0x000000000000000000000000642824fab1d0141073ed74326332950bec4701e3', '0x0000000000000000000000000000000000000000000000000000000000000756' ], transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41 } ], logsBloom: '0x20000080004000000000000400000000000001000000000400000000000000000000000000000000000000000008000000000000000000000000000000004000000000000008000000000008000000010080000014000004000000000000000000100000020800000000000000001800000080000000002000000010000000000000000000000200000200000000002000000000000400000000000000000000000000000000000000000040000000000000000100000000000000000000040002100002000000000000080000000000000100000002000000040000001220000000000000000000000000000000000000000000000000000000000000004000', status: 1, to: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', transactionHash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', transactionIndex: 41, type: 2, byzantium: true, confirmations: 40 }
  * ```
- */
-function cleanTransactionReceipt(transactionReceipt) {
-    const cleanedTransaction = (0, clean_transaction_1.cleanTransaction)(transactionReceipt);
-    const cleanedTransactionReceipt = Object.assign({}, cleanedTransaction);
-    Object.keys(transactionReceipt).forEach((key) => {
-        if (!transactionReceipt[key])
-            return;
-        switch (key) {
-            case 'status':
-                cleanedTransactionReceipt[key] = Number((0, hex_to_decimal_1.hexToDecimal)(transactionReceipt[key]));
+ */ export function cleanTransactionReceipt(transactionReceipt) {
+    var cleanedTransaction = cleanTransaction(transactionReceipt);
+    var cleanedTransactionReceipt = _objectSpread({}, cleanedTransaction);
+    Object.keys(transactionReceipt).forEach(function(key) {
+        if (!transactionReceipt[key]) return;
+        switch(key){
+            case "status":
+                cleanedTransactionReceipt[key] = Number(hexToDecimal(transactionReceipt[key]));
                 break;
-            case 'contractAddress':
+            case "contractAddress":
                 if (transactionReceipt[key]) {
-                    cleanedTransactionReceipt[key] = (0, __1.toChecksumAddress)(transactionReceipt[key]);
+                    cleanedTransactionReceipt[key] = toChecksumAddress(transactionReceipt[key]);
                 }
                 break;
-            case 'cumulativeGasUsed':
-            case 'effectiveGasPrice':
-            case 'gasUsed':
-                cleanedTransactionReceipt[key] = (0, __1.tinyBig)((0, hex_to_decimal_1.hexToDecimal)(transactionReceipt[key]));
+            case "cumulativeGasUsed":
+            case "effectiveGasPrice":
+            case "gasUsed":
+                cleanedTransactionReceipt[key] = tinyBig(hexToDecimal(transactionReceipt[key]));
                 break;
-            case 'logs':
-                transactionReceipt[key].forEach((log, index) => {
-                    cleanedTransactionReceipt[key][index] = (0, clean_log_1.cleanLog)(log, true);
+            case "logs":
+                transactionReceipt[key].forEach(function(log, index) {
+                    cleanedTransactionReceipt[key][index] = cleanLog(log, true);
                 });
         }
     });
-    cleanedTransactionReceipt.byzantium =
-        cleanedTransactionReceipt.blockNumber >= 4370000;
+    cleanedTransactionReceipt.byzantium = cleanedTransactionReceipt.blockNumber >= 4370000;
     return cleanedTransactionReceipt;
 }
-exports.cleanTransactionReceipt = cleanTransactionReceipt;

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

@@ -1,8 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanTransaction = void 0;
-const __1 = require("../..");
-const hex_to_decimal_1 = require("./hex-to-decimal");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+import { tinyBig } from "../../shared/tiny-big/tiny-big";
+import { toChecksumAddress } from "../../utils/to-checksum-address";
+import { hexToDecimal } from "./hex-to-decimal";
 /**
  * Converts RPC transaction response to more JS-friendly format
  *
@@ -14,38 +40,35 @@ const hex_to_decimal_1 = require("./hex-to-decimal");
  * cleanTransaction(RPCTransaction);
  * // { accessList: [], blockHash: '0x03ddc6a835462f750fcaf5ab511d8c48121b0813e3e80de84d7adc3ef192b7bf', blockNumber: 14847842, chainId: 1, from: '0x642824FaB1D0141073ed74326332950bEc4701e3', gas: Big { s: 1, e: 5, c: [ 1, 6, 0, 9, 5, 1 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, gasPrice: Big { s: 1, e: 10, c: [ 2, 6, 5, 4, 0, 6, 2, 3, 4, 0, 4 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, hash: '0xd0befcb9d10a89aba2d488534811bf5c62a889e2499d23cdd83c2a2200cde873', input: '0xa0712d68000000000000000000000000000000000000000000000000000000000000000a', maxFeePerGas: Big { s: 1, e: 10, c: [ 4, 0, 9, 3, 6, 9, 8, 9, 6, 8 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, maxPriorityFeePerGas: Big { s: 1, e: 9, c: [ 1 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, nonce: 66, r: '0x304682f8b22006dd1347c3722f6e43a5ad8e3a1ae51939cc0d6f07981602f5c0', s: '0x207ad110eb5c014cb628814b92396785fabfbe74542293300eeadf156f50f105', to: '0x84F80EA01e26B7C11bdd241970982C7EEAb6DdcC', transactionIndex: 41, type: 2, v: 1, value: Big { s: 1, e: 16, c: [ 2 ], constructor: { [λ: Big] DP: 20, RM: 1, NE: -7, PE: 21, strict: false, roundDown: 0, roundHalfUp: 1, roundHalfEven: 2, roundUp: 3, Big: [Circular], default: [Circular] }, padAndChop: [λ] }, confirmations: 53 }
  * ```
- */
-function cleanTransaction(transaction) {
-    const cleanedTransaction = Object.assign({}, transaction);
-    Object.keys(transaction).forEach((key) => {
+ */ export function cleanTransaction(transaction) {
+    var cleanedTransaction = _objectSpread({}, transaction);
+    Object.keys(transaction).forEach(function(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 'chainId':
-            case 'transactionIndex':
-            case 'type':
-            case 'v':
-                cleanedTransaction[key] = Number((0, hex_to_decimal_1.hexToDecimal)(transaction[key]));
+        if (!transaction[key]) return;
+        switch(key){
+            case "blockNumber":
+            case "chainId":
+            case "transactionIndex":
+            case "type":
+            case "v":
+                cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
                 break;
-            case 'from':
-            case 'to':
+            case "from":
+            case "to":
                 if (transaction[key]) {
-                    cleanedTransaction[key] = (0, __1.toChecksumAddress)(transaction[key]);
+                    cleanedTransaction[key] = toChecksumAddress(transaction[key]);
                 }
                 break;
-            case 'value':
-            case 'gas':
-            case 'gasPrice':
-            case 'maxFeePerGas':
-            case 'maxPriorityFeePerGas':
-            case 'nonce':
-                cleanedTransaction[key] = (0, __1.tinyBig)((0, hex_to_decimal_1.hexToDecimal)(transaction[key]));
+            case "value":
+            case "gas":
+            case "gasPrice":
+            case "maxFeePerGas":
+            case "maxPriorityFeePerGas":
+            case "nonce":
+                cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
                 break;
         }
     });
     return cleanedTransaction;
 }
-exports.cleanTransaction = cleanTransaction;

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

@@ -1,4 +1,4 @@
 import type { JSONABIArgument } from '../../types/Contract.types';
 export declare const hexFalse: string;
 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)[];
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig | (string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig)[];

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

@@ -1,11 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeRPCResponse = exports.encodeData = exports.hexFalse = void 0;
-const sha3_1 = require("sha3");
-const __1 = require("../..");
-const hex_to_decimal_1 = require("./hex-to-decimal");
-exports.hexFalse = '0'.repeat(64);
-const hexTrue = '0'.repeat(63) + '1';
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { Keccak } from "sha3";
+import { tinyBig } from "../../shared/tiny-big/tiny-big";
+import { toChecksumAddress } from "../../utils/to-checksum-address";
+import { hexToDecimal } from "./hex-to-decimal";
+export var hexFalse = "0".repeat(64);
+var hexTrue = "0".repeat(63) + "1";
+/**
+ * @param hex
+ * @example
+ */ function hexToUtf8(hex) {
+    var str = "";
+    var i = 0;
+    var l = hex.length;
+    if (hex.substring(0, 2) === "0x") {
+        i = 2;
+    }
+    for(; i < l; i += 2){
+        var code = parseInt(hex.substr(i, 2), 16);
+        if (code === 0) continue; // Skip null bytes
+        str += String.fromCharCode(code);
+    }
+    try {
+        return decodeURIComponent(escape(str)); // Convert UTF-8 to Unicode
+    } catch (e) {
+        return str; // Return original string if conversion fails
+    }
+}
 /**
  * Expands an integer type to use a default of 256 bits. Used for consistency; not required in Solidity
  *
@@ -17,14 +82,12 @@ const hexTrue = '0'.repeat(63) + '1';
  * expandType('uint[]');
  * // 'uint256[]'
  * ```
- */
-function expandType(type) {
+ */ 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[]';
+    if (type === "uint[]") {
+        return "uint256[]";
+    } else if (type === "int[]") {
+        return "int256[]";
     }
     return type;
 }
@@ -33,106 +96,123 @@ function expandType(type) {
  * @param jsonABIArgument
  * @param args
  * @example
- */
-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))})`;
+ */ export function encodeData(jsonABIArgument, args) {
+    var hash = new Keccak(256);
+    /* first 4 bytes will create the data parameter */ var functionString = "".concat(jsonABIArgument.name, "(").concat(jsonABIArgument.inputs.map(function(input) {
+        return 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');
+    var functionHash = hash.update(functionString).digest("hex");
     // no arrays
-    const jsonABIInputsLength = jsonABIArgument.inputs.length;
-    let shouldValidateInputLength = true;
+    var jsonABIInputsLength = jsonABIArgument.inputs.length;
+    var shouldValidateInputLength = true;
     // inputs contains 1 or more arrays
-    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+    if (jsonABIArgument.inputs.find(function(input) {
+        return 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}"`);
+        throw new Error('args inputs  of "'.concat(args.length, '" does not match expected length of "').concat(jsonABIArgument.inputs.length, '"'));
     }
-    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
-        var _a;
-        if (input.type.includes('[')) {
+    var argsWithTypes = (jsonABIArgument.inputs || []).reduce(function(acc, input, i) {
+        if (input.type.includes("[")) {
+            var _exec;
             // 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]]);
+            var basicType = (_exec = /([^[]*)\[.*$/g.exec(input.type)) === null || _exec === void 0 ? void 0 : _exec[1];
+            args.forEach(function(arg) {
+                acc = acc.concat([
+                    [
+                        arg,
+                        basicType
+                    ]
+                ]);
             });
             return acc;
-        }
-        else {
-            return acc.concat([[args[i], input.type]]);
+        } else {
+            return acc.concat([
+                [
+                    args[i],
+                    input.type
+                ]
+            ]);
         }
     }, []);
-    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
-        let rawArg = arg;
-        switch (inputType) {
-            case 'bool':
-                return arg ? hexTrue : exports.hexFalse;
-            case 'address':
+    var encodedArgs = argsWithTypes.map(function(param) {
+        var _param = _slicedToArray(param, 2), arg = _param[0], inputType = _param[1];
+        var rawArg = arg;
+        switch(inputType){
+            case "bool":
+                return arg ? hexTrue : hexFalse;
+            case "address":
                 // remove leading "0x"
-                rawArg = arg.replace(/^0x/g, '').toLowerCase();
+                rawArg = arg.replace(/^0x/g, "").toLowerCase();
                 break;
             default:
-                if (inputType.startsWith('bytes')) {
+                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');
+                    var argEncoded = rawArg.split("").map(function(character) {
+                        return character.charCodeAt(0).toString(16);
+                    }).join("");
+                    var 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')) {
+                } else if (inputType === "uint256") {
+                    var argEncoded1 = BigInt(arg).toString(16);
+                    var paddedEncodedArg1 = argEncoded1.padStart(64, "0");
+                    return paddedEncodedArg1;
+                } else if (inputType.startsWith("uint")) {
                     break;
-                }
-                else {
-                    throw new Error(`essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`);
+                } else {
+                    throw new Error('essential-eth does not yet support "'.concat(inputType, '" inputs. Make a PR today!"'));
                 }
         }
-        const argEncoded = rawArg.toString(16);
-        const paddedEncodedArg = argEncoded.padStart(64, '0');
-        return paddedEncodedArg;
+        var argEncoded2 = rawArg.toString(16);
+        var paddedEncodedArg2 = argEncoded2.padStart(64, "0");
+        return paddedEncodedArg2;
     });
-    const functionEncoded = functionHash.slice(0, 8);
-    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+    var functionEncoded = functionHash.slice(0, 8);
+    var data = "0x".concat(functionEncoded).concat(encodedArgs.join(""));
     return data;
 }
-exports.encodeData = encodeData;
 /**
  * @internal
  * @param jsonABIArgument
  * @param nodeResponse
  * @example
- */
-function decodeRPCResponse(jsonABIArgument, nodeResponse) {
-    const rawOutputs = jsonABIArgument.outputs;
+ */ export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    var _jsonABIArgument_outputs;
+    var rawOutputs = jsonABIArgument.outputs;
+    var slicedResponse = nodeResponse.slice(2);
+    if ((jsonABIArgument === null || jsonABIArgument === void 0 ? void 0 : (_jsonABIArgument_outputs = jsonABIArgument.outputs) === null || _jsonABIArgument_outputs === void 0 ? void 0 : _jsonABIArgument_outputs.length) === 1 && jsonABIArgument.outputs[0].type === "string") {
+        var _ref = [
+            slicedResponse.slice(0, 64),
+            slicedResponse.slice(64)
+        ], hexOffset = _ref[0], responseData = _ref[1];
+        var decimalOffset = Number(hexToDecimal("0x".concat(hexOffset)));
+        var hexLength = responseData.slice(0, decimalOffset * 2);
+        var decimalLength = Number(hexToDecimal("0x".concat(hexLength)));
+        var hexToDecode = responseData.slice(decimalOffset * 2, decimalOffset * 2 + decimalLength * 2);
+        return hexToUtf8(hexToDecode);
+    }
     // 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':
+    var encodedOutputs = slicedResponse.match(/.{1,64}/g);
+    var outputs = (encodedOutputs || []).map(function(output, i) {
+        var 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':
-            case 'uint120':
-                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}`));
+            case "address":
+                /* address types have 24 leading zeroes to remove */ return toChecksumAddress("0x".concat(output.slice(24)));
+            case "uint256":
+            case "uint120":
+                return tinyBig(hexToDecimal("0x".concat(output)));
+            case "bytes32":
+                return "0x".concat(output);
+            case "uint8":
+                return Number(hexToDecimal("0x".concat(output)));
             default:
-                throw new Error(`essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`);
+                throw new Error('essential-eth does not yet support "'.concat(outputType, '" outputs. Make a PR today!"'));
         }
     });
     return outputs.length === 1 ? outputs[0] : outputs;
 }
-exports.decodeRPCResponse = decodeRPCResponse;