web3-abii 4.3.0

package/lib/types/api/parameters_api.d.ts

@@ -0,0 +1,239 @@
+import { AbiInput, HexString } from 'web3-types';
+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 declare const encodeParameter: (abi: AbiInput, param: unknown) => string;
+/**
+ * Should be used to decode list of params
+ */
+export declare const decodeParametersWith: (abis: AbiInput[] | ReadonlyArray<AbiInput>, bytes: HexString, loose: boolean) => {
+    [key: string]: unknown;
+    __length__: number;
+};
+/**
+ * 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 declare const decodeParameters: (abi: AbiInput[] | ReadonlyArray<AbiInput>, bytes: HexString) => {
+    [key: string]: unknown;
+    __length__: number;
+};
+/**
+ * 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 declare const decodeParameter: (abi: AbiInput, bytes: HexString) => unknown;
+//# sourceMappingURL=parameters_api.d.ts.map

package/lib/types/api/parameters_api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters_api.d.ts","sourceRoot":"","sources":["../../../src/api/parameters_api.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAIjD,OAAO,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,eAAe,QAAS,QAAQ,SAAS,OAAO,KAAG,MAC/B,CAAC;AAClC;;GAEG;AACH,eAAO,MAAM,oBAAoB,SAC1B,QAAQ,EAAE,GAAG,cAAc,QAAQ,CAAC,SACnC,SAAS,SACT,OAAO;;gBAC0B,MAAM;CAiB9C,CAAC;AAEF;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,eAAO,MAAM,gBAAgB,QACvB,QAAQ,EAAE,GAAG,cAAc,QAAQ,CAAC,SAClC,SAAS;;gBACwB,MAAM;CAA6C,CAAC;AAE7F;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,eAAe,QAAS,QAAQ,SAAS,SAAS,KAAG,OAC9B,CAAC"}

package/lib/types/coders/base/address.d.ts

@@ -0,0 +1,5 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeAddress(param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeAddress(_param: AbiParameter, bytes: Uint8Array): DecoderResult<string>;
+//# sourceMappingURL=address.d.ts.map

package/lib/types/coders/base/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/address.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAM3D,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CA4BhF;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAkB5F"}

package/lib/types/coders/base/array.d.ts

@@ -0,0 +1,5 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeArray(param: AbiParameter, values: unknown): EncoderResult;
+export declare function decodeArray(param: AbiParameter, bytes: Uint8Array): DecoderResult<unknown[]>;
+//# sourceMappingURL=array.d.ts.map

package/lib/types/coders/base/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/array.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAK3D,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,aAAa,CAuC/E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC,CAoD5F"}

package/lib/types/coders/base/bool.d.ts

@@ -0,0 +1,5 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeBoolean(param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeBool(_param: AbiParameter, bytes: Uint8Array): DecoderResult<boolean>;
+//# sourceMappingURL=bool.d.ts.map

package/lib/types/coders/base/bool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bool.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/bool.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAI3D,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAehF;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,CAa1F"}

package/lib/types/coders/base/bytes.d.ts

@@ -0,0 +1,5 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeBytes(param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeBytes(param: AbiParameter, bytes: Uint8Array): DecoderResult<string>;
+//# sourceMappingURL=bytes.d.ts.map

package/lib/types/coders/base/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/bytes.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAS,MAAM,YAAY,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAM3D,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAkD9E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CA2BzF"}

package/lib/types/coders/base/index.d.ts

@@ -0,0 +1,12 @@
+import { AbiParameter } from 'web3-types';
+import { EncoderResult, DecoderResult } from '../types.js';
+export { encodeAddress, decodeAddress } from './address.js';
+export { encodeBoolean, decodeBool } from './bool.js';
+export { encodeBytes, decodeBytes } from './bytes.js';
+export { encodeNumber, decodeNumber } from './number.js';
+export { encodeString, decodeString } from './string.js';
+export { encodeTuple, decodeTuple } from './tuple.js';
+export { encodeArray, decodeArray } from './array.js';
+export declare function encodeParamFromAbiParameter(param: AbiParameter, value: unknown): EncoderResult;
+export declare function decodeParamFromAbiParameter(param: AbiParameter, bytes: Uint8Array): DecoderResult;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/coders/base/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAW3D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CA0B9F;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CA0BjG"}

package/lib/types/coders/base/number.d.ts

@@ -0,0 +1,5 @@
+import type { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeNumber(param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeNumber(param: AbiParameter, bytes: Uint8Array): DecoderResult<bigint>;
+//# sourceMappingURL=number.d.ts.map

package/lib/types/coders/base/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/number.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAyB3D,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAmC/E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAgC1F"}

package/lib/types/coders/base/numbersLimits.d.ts

@@ -0,0 +1,5 @@
+export declare const numberLimits: Map<string, {
+    min: bigint;
+    max: bigint;
+}>;
+//# sourceMappingURL=numbersLimits.d.ts.map

package/lib/types/coders/base/numbersLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbersLimits.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/numbersLimits.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,YAAY;SAA0B,MAAM;SAAO,MAAM;EAAK,CAAC"}

package/lib/types/coders/base/string.d.ts

@@ -0,0 +1,5 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeString(_param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeString(_param: AbiParameter, bytes: Uint8Array): DecoderResult<string>;
+//# sourceMappingURL=string.d.ts.map

package/lib/types/coders/base/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/string.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG3D,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAMhF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAO3F"}

package/lib/types/coders/base/tuple.d.ts

@@ -0,0 +1,8 @@
+import { AbiParameter } from 'web3-types';
+import { DecoderResult, EncoderResult } from '../types.js';
+export declare function encodeTuple(param: AbiParameter, input: unknown): EncoderResult;
+export declare function decodeTuple(param: AbiParameter, bytes: Uint8Array): DecoderResult<{
+    [key: string]: unknown;
+    __length__: number;
+}>;
+//# sourceMappingURL=tuple.d.ts.map

package/lib/types/coders/base/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/tuple.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAO3D,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAkD9E;AAED,wBAAgB,WAAW,CAC1B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,UAAU,GACf,aAAa,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAgD/D"}

package/lib/types/coders/base/utils.d.ts

@@ -0,0 +1,3 @@
+import { EncoderResult } from '../types.js';
+export declare function encodeDynamicParams(encodedParams: ReadonlyArray<EncoderResult>): Uint8Array;
+//# sourceMappingURL=utils.d.ts.map

package/lib/types/coders/base/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/coders/base/utils.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAI5C,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,UAAU,CA6B3F"}

package/lib/types/coders/decode.d.ts

@@ -0,0 +1,6 @@
+import { AbiInput, HexString } from 'web3-types';
+export declare function decodeParameters(abis: AbiInput[] | ReadonlyArray<AbiInput>, bytes: HexString, _loose: boolean): {
+    [key: string]: unknown;
+    __length__: number;
+};
+//# sourceMappingURL=decode.d.ts.map

package/lib/types/coders/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/coders/decode.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKjD,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,QAAQ,EAAE,GAAG,aAAa,CAAC,QAAQ,CAAC,EAC1C,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,OAAO,GACb;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAKhD"}

package/lib/types/coders/encode.d.ts

@@ -0,0 +1,39 @@
+import { AbiInput } from 'web3-types';
+/**
+ * Encodes a parameter based on its type to its ABI representation.
+ * @param abi - An array of {@link AbiInput}. See [Solidity's documentation](https://solidity.readthedocs.io/en/v0.5.3/abi-spec.html#json) for more details.
+ * @param params - The actual parameters to encode.
+ * @returns - The ABI encoded parameters
+ * @example
+ * ```ts
+ * const res = web3.eth.abi.encodeParameters(
+ *    ["uint256", "string"],
+ *    ["2345675643", "Hello!%"]
+ *  );
+ *
+ *  console.log(res);
+ *  > 0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000
+ * ```
+ */
+export declare function encodeParameters(abi: ReadonlyArray<AbiInput>, params: unknown[]): string;
+/**
+ * Infer a smart contract method parameter type and then encode this parameter.
+ * @param params - The parameters to encode.
+ * @returns - The ABI encoded parameters
+ *
+ * @remarks
+ * This method is useful when you don't know the type of the parameters you want to encode. It will infer the type of the parameters and then encode them.
+ * However, it is not recommended to use this method when you know the type of the parameters you want to encode. In this case, use the {@link encodeParameters} method instead.
+ * The type inference is not perfect and can lead to unexpected results. Especially when you want to encode an array, uint that is not uint256 or bytes....
+ * @example
+ * ```ts
+ * const res = web3.eth.abi.encodeParameters(
+ *    ["2345675643", "Hello!%"]
+ *  );
+ *
+ *  console.log(res);
+ *  > 0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000
+ * ```
+ */
+export declare function inferTypesAndEncodeParameters(params: unknown[]): string;
+//# sourceMappingURL=encode.d.ts.map

package/lib/types/coders/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/coders/encode.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AAmCpD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAYxF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAYvE"}

package/lib/types/coders/types.d.ts

@@ -0,0 +1,17 @@
+export declare type EncoderResult = {
+    dynamic: boolean;
+    encoded: Uint8Array;
+};
+export declare type DecoderResult<T = unknown> = {
+    result: T;
+    encoded: Uint8Array;
+    consumed: number;
+};
+export declare type NumberType = {
+    signed: boolean;
+    byteLength: number;
+};
+export declare type BytesType = {
+    size?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/coders/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/coders/types.ts"],"names":[],"mappings":"AAiBA,oBAAY,aAAa,GAAG;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,OAAO,EAAE,UAAU,CAAC;CACpB,CAAC;AACF,oBAAY,aAAa,CAAC,CAAC,GAAG,OAAO,IAAI;IACxC,MAAM,EAAE,CAAC,CAAC;IAGV,OAAO,EAAE,UAAU,CAAC;IAGpB,QAAQ,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,oBAAY,UAAU,GAAG;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,oBAAY,SAAS,GAAG;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,CAAC"}

package/lib/types/coders/utils.d.ts

@@ -0,0 +1,24 @@
+import { AbiParameter as ExternalAbiParameter } from 'abitype';
+import { AbiInput, AbiParameter } from 'web3-types';
+export declare const WORD_SIZE = 32;
+export declare function alloc(size?: number): Uint8Array;
+/**
+ * Where possible returns a Uint8Array of the requested size that references
+ * uninitialized memory. Only use if you are certain you will immediately
+ * overwrite every value in the returned `Uint8Array`.
+ */
+export declare function allocUnsafe(size?: number): Uint8Array;
+export declare function convertExternalAbiParameter(abiParam: ExternalAbiParameter): AbiParameter;
+export declare function isAbiParameter(param: unknown): param is AbiParameter;
+export declare function toAbiParams(abi: ReadonlyArray<AbiInput>): ReadonlyArray<AbiParameter>;
+export declare function extractArrayType(param: AbiParameter): {
+    size: number;
+    param: AbiParameter;
+};
+/**
+ * Param is dynamic if it's dynamic base type or if some of his children (components, array items)
+ * is of dynamic type
+ * @param param
+ */
+export declare function isDynamic(param: AbiParameter): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/lib/types/coders/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/coders/utils.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,IAAI,oBAAoB,EAAqB,MAAM,SAAS,CAAC;AAElF,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAa,MAAM,YAAY,CAAC;AAQ/D,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,wBAAgB,KAAK,CAAC,IAAI,SAAI,GAAG,UAAU,CAO1C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,SAAI,GAAG,UAAU,CAOhD;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,oBAAoB,GAAG,YAAY,CAQxF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAOpE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,aAAa,CAAC,YAAY,CAAC,CAsBrF;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CAgB3F;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAStD"}

package/lib/types/decode_contract_error_data.d.ts

@@ -0,0 +1,4 @@
+import { Eip838ExecutionError } from 'web3-errors';
+import { AbiErrorFragment } from 'web3-types';
+export declare const decodeContractErrorData: (errorsAbi: AbiErrorFragment[], error: Eip838ExecutionError) => void;
+//# sourceMappingURL=decode_contract_error_data.d.ts.map

package/lib/types/decode_contract_error_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_contract_error_data.d.ts","sourceRoot":"","sources":["../../src/decode_contract_error_data.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAM9C,eAAO,MAAM,uBAAuB,cACxB,gBAAgB,EAAE,SACtB,oBAAoB,SAqD3B,CAAC"}

package/lib/types/eip_712.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The web3.eth.abi functions let you encode and decode parameters to ABI (Application Binary Interface) for function calls to the EVM (Ethereum Virtual Machine).
+ *
+ *  For using Web3 ABI functions, first install Web3 package using `npm i web3` or `yarn add web3`.
+ * After that, Web3 ABI functions will be available.
+ * ```ts
+ * import { Web3 } from 'web3';
+ *
+ * const web3 = new Web3();
+ * const encoded = web3.eth.abi.encodeFunctionSignature({
+ *     name: 'myMethod',
+ *     type: 'function',
+ *     inputs: [{
+ *         type: 'uint256',
+ *         name: 'myNumber'
+ *     },{
+ *         type: 'string',
+ *         name: 'myString'
+ *     }]
+ * });
+ *
+ * ```
+ *
+ * For using individual package install `web3-eth-abi` package using `npm i web3-eth-abi` or `yarn add web3-eth-abi` and only import required functions.
+ * This is more efficient approach for building lightweight applications.
+ * ```ts
+ * import { encodeFunctionSignature } from 'web3-eth-abi';
+ *
+ * const encoded = encodeFunctionSignature({
+ *     name: 'myMethod',
+ *     type: 'function',
+ *     inputs: [{
+ *         type: 'uint256',
+ *         name: 'myNumber'
+ *     },{
+ *         type: 'string',
+ *         name: 'myString'
+ *     }]
+ * });
+ *
+ * ```
+ *
+ *  @module ABI
+ */
+import { Eip712TypedData } from 'web3-types';
+/**
+ * Get the EIP-191 encoded message to sign, from the typedData object. If `hash` is enabled, the message will be hashed
+ * with Keccak256.
+ */
+export declare const getMessage: (typedData: Eip712TypedData, hash?: boolean) => string;
+//# sourceMappingURL=eip_712.d.ts.map

package/lib/types/eip_712.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip_712.d.ts","sourceRoot":"","sources":["../../src/eip_712.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkF7C;;;GAGG;AACH,eAAO,MAAM,UAAU,cAAe,eAAe,SAAS,OAAO,KAAG,MAevE,CAAC"}

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './api/errors_api.js';
+export * from './api/events_api.js';
+export * from './api/functions_api.js';
+export * from './api/logs_api.js';
+export * from './api/parameters_api.js';
+export * from './utils.js';
+export * from './decode_contract_error_data.js';
+export { getMessage as getEncodedEip712Data } from './eip_712.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAiBA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,iCAAiC,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/lib/types/utils.d.ts

@@ -0,0 +1,44 @@
+import { AbiInput, AbiCoderStruct, AbiFragment, AbiParameter, AbiStruct, AbiEventFragment, AbiFunctionFragment, AbiConstructorFragment } from 'web3-types';
+export declare const isAbiFragment: (item: unknown) => item is AbiFragment;
+export declare const isAbiErrorFragment: (item: unknown) => item is AbiEventFragment;
+export declare const isAbiEventFragment: (item: unknown) => item is AbiEventFragment;
+export declare const isAbiFunctionFragment: (item: unknown) => item is AbiFunctionFragment;
+export declare const isAbiConstructorFragment: (item: unknown) => item is AbiConstructorFragment;
+/**
+ * Check if type is simplified struct format
+ */
+export declare const isSimplifiedStructFormat: (type: string | Partial<AbiParameter> | Partial<AbiInput>) => type is Omit<AbiParameter, "components" | "name">;
+/**
+ * Maps the correct tuple type and name when the simplified format in encode/decodeParameter is used
+ */
+export declare const mapStructNameAndType: (structName: string) => AbiStruct;
+/**
+ * Maps the simplified format in to the expected format of the ABICoder
+ */
+export declare const mapStructToCoderFormat: (struct: AbiStruct) => Array<AbiCoderStruct>;
+/**
+ * Map types if simplified format is used
+ */
+export declare const mapTypes: (types: AbiInput[]) => Array<string | AbiParameter | Record<string, unknown>>;
+/**
+ * returns true if input is a hexstring and is odd-lengthed
+ */
+export declare const isOddHexstring: (param: unknown) => boolean;
+/**
+ * format odd-length bytes to even-length
+ */
+export declare const formatOddHexstrings: (param: string) => string;
+/**
+ * Handle some formatting of params for backwards compatibility with Ethers V4
+ */
+export declare const formatParam: (type: string, _param: unknown) => unknown;
+/**
+ *  used to flatten json abi inputs/outputs into an array of type-representing-strings
+ */
+export declare const flattenTypes: (includeTuple: boolean, puts: ReadonlyArray<AbiParameter>) => string[];
+/**
+ * Should be used to create full function/event name from json abi
+ * returns a string
+ */
+export declare const jsonInterfaceMethodToString: (json: AbiFragment) => string;
+//# sourceMappingURL=utils.d.ts.map

package/lib/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAmBA,OAAO,EACN,QAAQ,EACR,cAAc,EACd,WAAW,EACX,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,aAAa,SAAU,OAAO,wBAI6C,CAAC;AAEzF,eAAO,MAAM,kBAAkB,SAAU,OAAO,6BAIJ,CAAC;AAE7C,eAAO,MAAM,kBAAkB,SAAU,OAAO,6BAIJ,CAAC;AAE7C,eAAO,MAAM,qBAAqB,SAAU,OAAO,gCAIJ,CAAC;AAEhD,eAAO,MAAM,wBAAwB,SAAU,OAAO,mCAIJ,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,wBAAwB,SAC9B,MAAM,GAAG,QAAQ,YAAY,CAAC,GAAG,QAAQ,QAAQ,CAAC,sDAID,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,oBAAoB,eAAgB,MAAM,KAAG,SAGnB,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,sBAAsB,WAAY,SAAS,KAAG,MAAM,cAAc,CAmB9E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,UACb,QAAQ,EAAE,KACf,MAAM,MAAM,GAAG,YAAY,GAAG,OAAO,MAAM,EAAE,OAAO,CAAC,CAiCvD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,UAAW,OAAO,KAAG,OACwC,CAAC;AAEzF;;GAEG;AACH,eAAO,MAAM,mBAAmB,UAAW,MAAM,KAAG,MACO,CAAC;AAM5D;;GAEG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,UAAU,OAAO,KAAG,OAmD3D,CAAC;AAEF;;GAEG;AAEH,eAAO,MAAM,YAAY,iBACV,OAAO,QACf,cAAc,YAAY,CAAC,KAC/B,MAAM,EA2BR,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,2BAA2B,SAAU,WAAW,KAAG,MAW/D,CAAC"}