web3ethabii 4.3.0

package/lib/esm/api/errors_api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors_api.js","sourceRoot":"","sources":["../../../src/api/errors_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;EAeE;AAEF;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAE9E;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,YAAuC,EAAU,EAAE;IACvF,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE;QAC1E,MAAM,IAAI,QAAQ,CAAC,iDAAiD,CAAC,CAAC;KACtE;IAED,IAAI,IAAY,CAAC;IAEjB,IAAI,YAAY,IAAI,CAAC,OAAO,YAAY,KAAK,UAAU,IAAI,OAAO,YAAY,KAAK,QAAQ,CAAC,EAAE;QAC7F,IAAI,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;KACjD;SAAM;QACN,IAAI,GAAG,YAAY,CAAC;KACpB;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC,CAAC"}

package/lib/esm/api/events_api.js

@@ -0,0 +1,86 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ *
+ *  @module ABI
+ */
+import { sha3Raw } from 'web3-utils';
+import { AbiError } from 'web3-errors';
+import { jsonInterfaceMethodToString, isAbiEventFragment } from '../utils.js';
+/**
+ * Encodes the event name to its ABI signature, which are the sha3 hash of the event name including input types.
+ * @param functionName - The event name to encode, or the {@link AbiEventFragment} object of the event. If string, it has to be in the form of `eventName(param1Type,param2Type,...)`. eg: myEvent(uint256,bytes32).
+ * @returns - The ABI signature of the event.
+ *
+ * @example
+ * ```ts
+ * const event = web3.eth.abi.encodeEventSignature({
+ *   name: "myEvent",
+ *   type: "event",
+ *   inputs: [
+ *     {
+ *       type: "uint256",
+ *       name: "myNumber",
+ *     },
+ *     {
+ *       type: "bytes32",
+ *       name: "myBytes",
+ *     },
+ *   ],
+ * });
+ * console.log(event);
+ * > 0xf2eeb729e636a8cb783be044acf6b7b1e2c5863735b60d6daae84c366ee87d97
+ *
+ *  const event = web3.eth.abi.encodeEventSignature({
+ *   inputs: [
+ *     {
+ *       indexed: true,
+ *       name: "from",
+ *       type: "address",
+ *     },
+ *     {
+ *       indexed: true,
+ *       name: "to",
+ *       type: "address",
+ *     },
+ *     {
+ *       indexed: false,
+ *       name: "value",
+ *       type: "uint256",
+ *     },
+ *   ],
+ *   name: "Transfer",
+ *   type: "event",
+ * });
+ * console.log(event);
+ * > 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
+ * ```
+ */
+export const encodeEventSignature = (functionName) => {
+    if (typeof functionName !== 'string' && !isAbiEventFragment(functionName)) {
+        throw new AbiError('Invalid parameter value in encodeEventSignature');
+    }
+    let name;
+    if (functionName && (typeof functionName === 'function' || typeof functionName === 'object')) {
+        name = jsonInterfaceMethodToString(functionName);
+    }
+    else {
+        name = functionName;
+    }
+    return sha3Raw(name);
+};
+//# sourceMappingURL=events_api.js.map

package/lib/esm/api/events_api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events_api.js","sourceRoot":"","sources":["../../../src/api/events_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;EAeE;AAEF;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,YAAuC,EAAU,EAAE;IACvF,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE;QAC1E,MAAM,IAAI,QAAQ,CAAC,iDAAiD,CAAC,CAAC;KACtE;IAED,IAAI,IAAY,CAAC;IAEjB,IAAI,YAAY,IAAI,CAAC,OAAO,YAAY,KAAK,UAAU,IAAI,OAAO,YAAY,KAAK,QAAQ,CAAC,EAAE;QAC7F,IAAI,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;KACjD;SAAM;QACN,IAAI,GAAG,YAAY,CAAC;KACpB;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC,CAAC"}

package/lib/esm/api/functions_api.js

@@ -0,0 +1,134 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ *
+ *  @module ABI
+ */
+import { AbiError } from 'web3-errors';
+import { sha3Raw } from 'web3-utils';
+import { isAbiFunctionFragment, jsonInterfaceMethodToString } from '../utils.js';
+import { encodeParameters } from './parameters_api.js';
+/**
+ * Encodes the function name to its ABI representation, which are the first 4 bytes of the sha3 of the function name including  types.
+ * The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json
+ * @param functionName - The function name to encode or the `JSON interface` object of the function.
+ * If the passed parameter is a string, it has to be in the form of `functionName(param1Type,param2Type,...)`. eg: myFunction(uint256,uint32[],bytes10,bytes)
+ * @returns - The ABI signature of the function.
+ * @example
+ * ```ts
+ * const signature = web3.eth.abi.encodeFunctionSignature({
+ *   name: "myMethod",
+ *   type: "function",
+ *   inputs: [
+ *     {
+ *       type: "uint256",
+ *       name: "myNumber",
+ *     },
+ *     {
+ *       type: "string",
+ *       name: "myString",
+ *     },
+ *   ],
+ * });
+ * console.log(signature);
+ * > 0x24ee0097
+ *
+ * const signature = web3.eth.abi.encodeFunctionSignature('myMethod(uint256,string)')
+ * console.log(signature);
+ * > 0x24ee0097
+ *
+ * const signature = web3.eth.abi.encodeFunctionSignature('safeTransferFrom(address,address,uint256,bytes)');
+ * console.log(signature);
+ * > 0xb88d4fde
+ * ```
+ */
+export const encodeFunctionSignature = (functionName) => {
+    if (typeof functionName !== 'string' && !isAbiFunctionFragment(functionName)) {
+        throw new AbiError('Invalid parameter value in encodeFunctionSignature');
+    }
+    let name;
+    if (functionName && (typeof functionName === 'function' || typeof functionName === 'object')) {
+        name = jsonInterfaceMethodToString(functionName);
+    }
+    else {
+        name = functionName;
+    }
+    return sha3Raw(name).slice(0, 10);
+};
+/**
+ * Encodes a function call using its `JSON interface` object and given parameters.
+ * The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json
+ * @param jsonInterface - The `JSON interface` object of the function.
+ * @param params - The parameters to encode
+ * @returns - The ABI encoded function call, which, means the function signature and the parameters passed.
+ * @example
+ * ```ts
+ * const sig = web3.eth.abi.encodeFunctionCall(
+ *   {
+ *     name: "myMethod",
+ *     type: "function",
+ *     inputs: [
+ *       {
+ *         type: "uint256",
+ *         name: "myNumber",
+ *       },
+ *       {
+ *         type: "string",
+ *         name: "myString",
+ *       },
+ *     ],
+ *   },
+ *   ["2345675643", "Hello!%"]
+ * );
+ * console.log(sig);
+ * > 0x24ee0097000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000
+ *
+ *
+ *
+ * const sig = web3.eth.abi.encodeFunctionCall(
+ *   {
+ *     inputs: [
+ *       {
+ *         name: "account",
+ *         type: "address",
+ *       },
+ *     ],
+ *     name: "balanceOf",
+ *     outputs: [
+ *       {
+ *         name: "",
+ *         type: "uint256",
+ *       },
+ *     ],
+ *     stateMutability: "view",
+ *     type: "function",
+ *   },
+ *   ["0x1234567890123456789012345678901234567890"]
+ * );
+ *
+ * console.log(sig);
+ * > 0x70a082310000000000000000000000001234567890123456789012345678901234567890
+ * ```
+ */
+export const encodeFunctionCall = (jsonInterface, params) => {
+    var _a;
+    if (!isAbiFunctionFragment(jsonInterface)) {
+        throw new AbiError('Invalid parameter value in encodeFunctionCall');
+    }
+    return `${encodeFunctionSignature(jsonInterface)}${encodeParameters((_a = jsonInterface.inputs) !== null && _a !== void 0 ? _a : [], params !== null && params !== void 0 ? params : []).replace('0x', '')}`;
+};
+//# sourceMappingURL=functions_api.js.map

package/lib/esm/api/functions_api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions_api.js","sourceRoot":"","sources":["../../../src/api/functions_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;EAeE;AAEF;;;GAGG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,YAA0C,EAAU,EAAE;IAC7F,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,qBAAqB,CAAC,YAAY,CAAC,EAAE;QAC7E,MAAM,IAAI,QAAQ,CAAC,oDAAoD,CAAC,CAAC;KACzE;IAED,IAAI,IAAY,CAAC;IAEjB,IAAI,YAAY,IAAI,CAAC,OAAO,YAAY,KAAK,UAAU,IAAI,OAAO,YAAY,KAAK,QAAQ,CAAC,EAAE;QAC7F,IAAI,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;KACjD;SAAM;QACN,IAAI,GAAG,YAAY,CAAC;KACpB;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CACjC,aAAkC,EAClC,MAAiB,EACR,EAAE;;IACX,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,EAAE;QAC1C,MAAM,IAAI,QAAQ,CAAC,+CAA+C,CAAC,CAAC;KACpE;IAED,OAAO,GAAG,uBAAuB,CAAC,aAAa,CAAC,GAAG,gBAAgB,CAClE,MAAA,aAAa,CAAC,MAAM,mCAAI,EAAE,EAC1B,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CACZ,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC;AACvB,CAAC,CAAC"}

package/lib/esm/api/logs_api.js

@@ -0,0 +1,103 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+import { decodeParameter, decodeParametersWith } from './parameters_api.js';
+const STATIC_TYPES = ['bool', 'string', 'int', 'uint', 'address', 'fixed', 'ufixed'];
+const _decodeParameter = (inputType, clonedTopic) => inputType === 'string' ? clonedTopic : decodeParameter(inputType, clonedTopic);
+/**
+ * Decodes ABI-encoded log data and indexed topic data.
+ * @param inputs - A {@link AbiParameter} input array. See the [Solidity documentation](https://docs.soliditylang.org/en/develop/types.html) for a list of types.
+ * @param data - The ABI byte code in the `data` field of a log.
+ * @param topics - An array with the index parameter topics of the log, without the topic[0] if its a non-anonymous event, otherwise with topic[0]
+ * @returns - The result object containing the decoded parameters.
+ *
+ * @example
+ * ```ts
+ * let res = web3.eth.abi.decodeLog(
+ *    [
+ *      {
+ *        type: "string",
+ *        name: "myString",
+ *      },
+ *      {
+ *        type: "uint256",
+ *        name: "myNumber",
+ *        indexed: true,
+ *      },
+ *      {
+ *        type: "uint8",
+ *        name: "mySmallNumber",
+ *        indexed: true,
+ *      },
+ *    ],
+ *    "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000748656c6c6f252100000000000000000000000000000000000000000000000000",
+ *    [
+ *      "0x000000000000000000000000000000000000000000000000000000000000f310",
+ *      "0x0000000000000000000000000000000000000000000000000000000000000010",
+ *    ]
+ *  );
+ * > {
+ *  '0': 'Hello%!',
+ *  '1': 62224n,
+ *  '2': 16n,
+ *  __length__: 3,
+ *  myString: 'Hello%!',
+ *  myNumber: 62224n,
+ *  mySmallNumber: 16n
+ * }
+ * ```
+ */
+export const decodeLog = (inputs, data, topics) => {
+    const clonedTopics = Array.isArray(topics) ? topics : [topics];
+    const indexedInputs = {};
+    const nonIndexedInputs = {};
+    for (const [i, input] of inputs.entries()) {
+        if (input.indexed) {
+            indexedInputs[i] = input;
+        }
+        else {
+            nonIndexedInputs[i] = input;
+        }
+    }
+    const decodedNonIndexedInputs = data
+        ? decodeParametersWith(Object.values(nonIndexedInputs), data, true)
+        : { __length__: 0 };
+    // If topics are more than indexed inputs, that means first topic is the event signature
+    const offset = clonedTopics.length - Object.keys(indexedInputs).length;
+    const decodedIndexedInputs = Object.values(indexedInputs).map((input, index) => STATIC_TYPES.some(s => input.type.startsWith(s))
+        ? _decodeParameter(input.type, clonedTopics[index + offset])
+        : clonedTopics[index + offset]);
+    const returnValues = { __length__: 0 };
+    let indexedCounter = 0;
+    let nonIndexedCounter = 0;
+    for (const [i, res] of inputs.entries()) {
+        returnValues[i] = res.type === 'string' ? '' : undefined;
+        if (indexedInputs[i]) {
+            returnValues[i] = decodedIndexedInputs[indexedCounter];
+            indexedCounter += 1;
+        }
+        if (nonIndexedInputs[i]) {
+            returnValues[i] = decodedNonIndexedInputs[String(nonIndexedCounter)];
+            nonIndexedCounter += 1;
+        }
+        if (res.name) {
+            returnValues[res.name] = returnValues[i];
+        }
+        returnValues.__length__ += 1;
+    }
+    return returnValues;
+};
+//# sourceMappingURL=logs_api.js.map

package/lib/esm/api/logs_api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs_api.js","sourceRoot":"","sources":["../../../src/api/logs_api.ts"],"names":[],"mappings":"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"}

package/lib/esm/api/parameters_api.js

@@ -0,0 +1,271 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ *
+ *  @module ABI
+ */
+import { AbiError } from 'web3-errors';
+import { decodeParameters as decodeParametersInternal } from '../coders/decode.js';
+import { encodeParameters } from '../coders/encode.js';
+export { encodeParameters, inferTypesAndEncodeParameters } from '../coders/encode.js';
+/**
+ * Encodes a parameter based on its type to its ABI representation.
+ * @param abi -  The type of the parameter. See the [Solidity documentation](https://docs.soliditylang.org/en/develop/types.html) for a list of types.
+ * @param param - The actual parameter to encode.
+ * @returns -  The ABI encoded parameter
+ * @example
+ * ```ts
+ *  const res = web3.eth.abi.encodeParameter("uint256", "2345675643");
+ *  console.log(res);
+ *  0x000000000000000000000000000000000000000000000000000000008bd02b7b
+ *
+ *  const res = web3.eth.abi.encodeParameter("uint", "2345675643");
+ *
+ *  console.log(res);
+ *  >0x000000000000000000000000000000000000000000000000000000008bd02b7b
+ *
+ *    const res = web3.eth.abi.encodeParameter("bytes32", "0xdf3234");
+ *
+ *  console.log(res);
+ *  >0xdf32340000000000000000000000000000000000000000000000000000000000
+ *
+ *   const res = web3.eth.abi.encodeParameter("bytes", "0xdf3234");
+ *
+ *  console.log(res);
+ *  > 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003df32340000000000000000000000000000000000000000000000000000000000
+ *
+ *   const res = web3.eth.abi.encodeParameter("bytes32[]", ["0xdf3234", "0xfdfd"]);
+ *
+ *  console.log(res);
+ *  > 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002df32340000000000000000000000000000000000000000000000000000000000fdfd000000000000000000000000000000000000000000000000000000000000
+ *
+ *  const res = web3.eth.abi.encodeParameter(
+ *    {
+ *      ParentStruct: {
+ *        propertyOne: "uint256",
+ *        propertyTwo: "uint256",
+ *        childStruct: {
+ *          propertyOne: "uint256",
+ *          propertyTwo: "uint256",
+ *        },
+ *      },
+ *    },
+ *    {
+ *      propertyOne: 42,
+ *      propertyTwo: 56,
+ *      childStruct: {
+ *        propertyOne: 45,
+ *        propertyTwo: 78,
+ *      },
+ *    }
+ *  );
+ *
+ *  console.log(res);
+ *  > 0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e
+ * ```
+ */
+export const encodeParameter = (abi, param) => encodeParameters([abi], [param]);
+/**
+ * Should be used to decode list of params
+ */
+export const decodeParametersWith = (abis, bytes, loose) => {
+    try {
+        if (abis.length > 0 && (!bytes || bytes === '0x' || bytes === '0X')) {
+            throw new AbiError("Returned values aren't valid, did it run Out of Gas? " +
+                'You might also see this error if you are not using the ' +
+                'correct ABI for the contract you are retrieving data from, ' +
+                'requesting data from a block number that does not exist, ' +
+                'or querying a node which is not fully synced.');
+        }
+        return decodeParametersInternal(abis, `0x${bytes.replace(/0x/i, '')}`, loose);
+    }
+    catch (err) {
+        throw new AbiError(`Parameter decoding error: ${err.message}`, {
+            internalErr: err,
+        });
+    }
+};
+/**
+ * Should be used to decode list of params
+ */
+/**
+ * Decodes ABI encoded parameters to its JavaScript types.
+ * @param abi -  An array of {@link AbiInput}. See the [Solidity documentation](https://docs.soliditylang.org/en/develop/types.html) for a list of types.
+ * @param bytes - The ABI byte code to decode
+ * @returns - The result object containing the decoded parameters.
+ * @example
+ * ```ts
+ * let res = web3.eth.abi.decodeParameters(
+ *    ["string", "uint256"],
+ *    "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
+ *  );
+ *  console.log(res);
+ *  > { '0': 'Hello!%!', '1': 234n, __length__: 2 }
+ *
+ * let res = web3.eth.abi.decodeParameters(
+ *    [
+ *      {
+ *        type: "string",
+ *        name: "myString",
+ *      },
+ *      {
+ *        type: "uint256",
+ *        name: "myNumber",
+ *      },
+ *    ],
+ *    "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
+ *  );
+ * console.log(res);
+ *  > {
+ *  '0': 'Hello!%!',
+ *  '1': 234n,
+ *  __length__: 2,
+ *  myString: 'Hello!%!',
+ *  myNumber: 234n
+ * }
+ *
+ * const res = web3.eth.abi.decodeParameters(
+ *    [
+ *      "uint8[]",
+ *      {
+ *        ParentStruct: {
+ *          propertyOne: "uint256",
+ *          propertyTwo: "uint256",
+ *          childStruct: {
+ *            propertyOne: "uint256",
+ *            propertyTwo: "uint256",
+ *          },
+ *        },
+ *      },
+ *    ],
+ *    "0x00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000018"
+ *  );
+ *  console.log(res);
+ *  >
+ *  '0': [ 42n, 24n ],
+ *  '1': {
+ *    '0': 42n,
+ *    '1': 56n,
+ *    '2': {
+ *      '0': 45n,
+ *      '1': 78n,
+ *      __length__: 2,
+ *      propertyOne: 45n,
+ *      propertyTwo: 78n
+ *    },
+ *    __length__: 3,
+ *    propertyOne: 42n,
+ *    propertyTwo: 56n,
+ *    childStruct: {
+ *      '0': 45n,
+ *      '1': 78n,
+ *      __length__: 2,
+ *      propertyOne: 45n,
+ *      propertyTwo: 78n
+ *    }
+ *  },
+ *  __length__: 2,
+ *  ParentStruct: {
+ *    '0': 42n,
+ *    '1': 56n,
+ *    '2': {
+ *      '0': 45n,
+ *      '1': 78n,
+ *      __length__: 2,
+ *      propertyOne: 45n,
+ *      propertyTwo: 78n
+ *    },
+ *    __length__: 3,
+ *    propertyOne: 42n,
+ *    propertyTwo: 56n,
+ *    childStruct: {
+ *      '0': 45n,
+ *      '1': 78n,
+ *      __length__: 2,
+ *      propertyOne: 45n,
+ *      propertyTwo: 78n
+ *    }
+ *  }
+ *}
+ * ```
+ */
+export const decodeParameters = (abi, bytes) => decodeParametersWith(abi, bytes, false);
+/**
+ * Should be used to decode bytes to plain param
+ */
+/**
+ * Decodes an ABI encoded parameter to its JavaScript type.
+ * @param abi -  The type of the parameter. See the [Solidity documentation](https://docs.soliditylang.org/en/develop/types.html) for a list of types.
+ * @param bytes - The ABI byte code to decode
+ * @returns - The decoded parameter
+ * @example
+ * ```ts
+ *   const res = web3.eth.abi.decodeParameter(
+ *    "uint256",
+ *    "0x0000000000000000000000000000000000000000000000000000000000000010"
+ *  );
+ *  console.log(res);
+ * > 16n
+ *
+ *  const res = web3.eth.abi.decodeParameter(
+ *    "string",
+ *    "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
+ *  );
+ *
+ *  console.log(res);
+ *  > Hello!%!
+ *
+ *  const res = web3.eth.abi.decodeParameter(
+ *    {
+ *      ParentStruct: {
+ *        propertyOne: "uint256",
+ *        propertyTwo: "uint256",
+ *        childStruct: {
+ *          propertyOne: "uint256",
+ *          propertyTwo: "uint256",
+ *        },
+ *      },
+ *    },
+ *    "0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e"
+ *  );
+ *
+ *  console.log(res);
+ *   {
+ *  '0': 42n,
+ *  '1': 56n,
+ *  '2': {
+ *    '0': 45n,
+ *    '1': 78n,
+ *    __length__: 2,
+ *    propertyOne: 45n,
+ *    propertyTwo: 78n
+ *  },
+ *  __length__: 3,
+ *  propertyOne: 42n,
+ *  propertyTwo: 56n,
+ *  childStruct: {
+ *    '0': 45n,
+ *    '1': 78n,
+ *    __length__: 2,
+ *    propertyOne: 45n,
+ *    propertyTwo: 78n
+ *  }
+ *}
+ * ```
+ */
+export const decodeParameter = (abi, bytes) => decodeParameters([abi], bytes)['0'];
+//# sourceMappingURL=parameters_api.js.map

package/lib/esm/api/parameters_api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters_api.js","sourceRoot":"","sources":["../../../src/api/parameters_api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;EAeE;AAEF;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,GAAa,EAAE,KAAc,EAAU,EAAE,CACxE,gBAAgB,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;AAClC;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CACnC,IAA0C,EAC1C,KAAgB,EAChB,KAAc,EACmC,EAAE;IACnD,IAAI;QACH,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC,EAAE;YACpE,MAAM,IAAI,QAAQ,CACjB,uDAAuD;gBACtD,yDAAyD;gBACzD,6DAA6D;gBAC7D,2DAA2D;gBAC3D,+CAA+C,CAChD,CAAC;SACF;QACD,OAAO,wBAAwB,CAAC,IAAI,EAAE,KAAK,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;KAC9E;IAAC,OAAO,GAAG,EAAE;QACb,MAAM,IAAI,QAAQ,CAAC,6BAA8B,GAAa,CAAC,OAAO,EAAE,EAAE;YACzE,WAAW,EAAE,GAAG;SAChB,CAAC,CAAC;KACH;AACF,CAAC,CAAC;AAEF;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC/B,GAAyC,EACzC,KAAgB,EACiC,EAAE,CAAC,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAE7F;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,GAAa,EAAE,KAAgB,EAAW,EAAE,CAC3E,gBAAgB,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC"}