web3util 4.3.2

package/lib/esm/web3_eip1193_provider.js.map

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

package/lib/types/chunk_response_parser.d.ts

@@ -0,0 +1,15 @@
+import { JsonRpcResponse } from 'web3-types';
+import { EventEmitter } from 'eventemitter3';
+export declare class ChunkResponseParser {
+    private lastChunk;
+    private lastChunkTimeout;
+    private _clearQueues;
+    private readonly eventEmitter;
+    private readonly autoReconnect;
+    private readonly chunkTimeout;
+    constructor(eventEmitter: EventEmitter, autoReconnect: boolean);
+    private clearQueues;
+    onError(clearQueues?: () => void): void;
+    parseResponse(data: string): JsonRpcResponse[];
+}
+//# sourceMappingURL=chunk_response_parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_response_parser.d.ts","sourceRoot":"","sources":["../../src/chunk_response_parser.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAEnB,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO;IAKrE,OAAO,CAAC,WAAW;IAMZ,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,IAAI;IAIhC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE;CAsDrD"}

package/lib/types/converters.d.ts

@@ -0,0 +1,281 @@
+import { utf8ToBytes as ecUtf8ToBytes } from 'ethereum-cryptography/utils.js';
+import { Address, Bytes, HexString, Numbers, ValueTypes } from 'web3-types';
+/** @internal */
+export declare const ethUnitMap: {
+    noether: bigint;
+    wei: bigint;
+    kwei: bigint;
+    Kwei: bigint;
+    babbage: bigint;
+    femtoether: bigint;
+    mwei: bigint;
+    Mwei: bigint;
+    lovelace: bigint;
+    picoether: bigint;
+    gwei: bigint;
+    Gwei: bigint;
+    shannon: bigint;
+    nanoether: bigint;
+    nano: bigint;
+    szabo: bigint;
+    microether: bigint;
+    micro: bigint;
+    finney: bigint;
+    milliether: bigint;
+    milli: bigint;
+    ether: bigint;
+    kether: bigint;
+    grand: bigint;
+    mether: bigint;
+    gether: bigint;
+    tether: bigint;
+};
+export declare type EtherUnits = keyof typeof ethUnitMap;
+/**
+ * Convert a value from bytes to Uint8Array
+ * @param data - Data to be converted
+ * @returns - The Uint8Array representation of the input data
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.bytesToUint8Array("0xab")));
+ * > Uint8Array(1) [ 171 ]
+ * ```
+ */
+export declare const bytesToUint8Array: (data: Bytes) => Uint8Array | never;
+/**
+ * Convert a byte array to a hex string
+ * @param bytes - Byte array to be converted
+ * @returns - The hex string representation of the input byte array
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.bytesToHex(new Uint8Array([72, 12])));
+ * > "0x480c"
+ *
+ */
+export declare const bytesToHex: (bytes: Bytes) => HexString;
+/**
+ * Convert a hex string to a byte array
+ * @param hex - Hex string to be converted
+ * @returns - The byte array representation of the input hex string
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.hexToBytes('0x74657374'));
+ * > Uint8Array(4) [ 116, 101, 115, 116 ]
+ * ```
+ */
+export declare const hexToBytes: (bytes: HexString) => Uint8Array;
+/**
+ * Converts value to it's number representation
+ * @param value - Hex string to be converted
+ * @returns - The number representation of the input value
+ *
+ * @example
+ * ```ts
+ * conoslle.log(web3.utils.hexToNumber('0xa'));
+ * > 10
+ * ```
+ */
+export declare const hexToNumber: (value: HexString) => bigint | number;
+/**
+ * Converts value to it's number representation @alias `hexToNumber`
+ */
+export declare const toDecimal: (value: HexString) => bigint | number;
+/**
+ * Converts value to it's hex representation
+ * @param value - Value to be converted
+ * @param hexstrict - Add padding to converted value if odd, to make it hexstrict
+ * @returns - The hex representation of the input value
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.numberToHex(10));
+ * > "0xa"
+ * ```
+ */
+export declare const numberToHex: (value: Numbers, hexstrict?: boolean) => HexString;
+/**
+ * Converts value to it's hex representation @alias `numberToHex`
+ *
+ */
+export declare const fromDecimal: (value: Numbers, hexstrict?: boolean) => HexString;
+/**
+ * Converts value to it's decimal representation in string
+ * @param value - Hex string to be converted
+ * @returns - The decimal representation of the input value
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.hexToNumberString('0xa'));
+ * > "10"
+ * ```
+ */
+export declare const hexToNumberString: (data: HexString) => string;
+/**
+ * Should be called to get hex representation (prefixed by 0x) of utf8 string
+ * @param str - Utf8 string to be converted
+ * @returns - The hex representation of the input string
+ *
+ * @example
+ * ```ts
+ * console.log(utf8ToHex('web3.js'));
+ * > "0x776562332e6a73"
+ * ```
+ *
+ */
+export declare const utf8ToHex: (str: string) => HexString;
+/**
+ * @alias utf8ToHex
+ */
+export declare const fromUtf8: (str: string) => HexString;
+/**
+ * @alias utf8ToHex
+ */
+export declare const stringToHex: (str: string) => HexString;
+/**
+ * Should be called to get utf8 from it's hex representation
+ * @param str - Hex string to be converted
+ * @returns - Utf8 string
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.hexToUtf8('0x48656c6c6f20576f726c64'));
+ * > Hello World
+ * ```
+ */
+export declare const hexToUtf8: (str: HexString) => string;
+/**
+ * @alias hexToUtf8
+ */
+export declare const toUtf8: (input: HexString | Uint8Array) => string;
+export declare const utf8ToBytes: typeof ecUtf8ToBytes;
+/**
+ * @alias hexToUtf8
+ */
+export declare const hexToString: (str: HexString) => string;
+/**
+ * Should be called to get hex representation (prefixed by 0x) of ascii string
+ * @param str - String to be converted to hex
+ * @returns - Hex string
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.asciiToHex('Hello World'));
+ * > 0x48656c6c6f20576f726c64
+ * ```
+ */
+export declare const asciiToHex: (str: string) => HexString;
+/**
+ * @alias asciiToHex
+ */
+export declare const fromAscii: (str: string) => HexString;
+/**
+ * Should be called to get ascii from it's hex representation
+ * @param str - Hex string to be converted to ascii
+ * @returns - Ascii string
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.hexToAscii('0x48656c6c6f20576f726c64'));
+ * > Hello World
+ * ```
+ */
+export declare const hexToAscii: (str: HexString) => string;
+/**
+ * @alias hexToAscii
+ */
+export declare const toAscii: (str: HexString) => string;
+/**
+ * Auto converts any given value into it's hex representation.
+ * @param value - Value to be converted to hex
+ * @param returnType - If true, it will return the type of the value
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.toHex(10));
+ * > 0xa
+ *
+ * console.log(web3.utils.toHex('0x123', true));
+ * > bytes
+ *```
+ */
+export declare const toHex: (value: Numbers | Bytes | Address | boolean | object, returnType?: boolean) => HexString | ValueTypes;
+/**
+ * Converts any given value into it's number representation, if possible, else into it's bigint representation.
+ * @param value - The value to convert
+ * @returns - Returns the value in number or bigint representation
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.toNumber(1));
+ * > 1
+ * console.log(web3.utils.toNumber(Number.MAX_SAFE_INTEGER));
+ * > 9007199254740991
+ *
+ * console.log(web3.utils.toNumber(BigInt(Number.MAX_SAFE_INTEGER)));
+ * > 9007199254740991
+ *
+ * console.log(web3.utils.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)));
+ * > 9007199254740992n
+ *
+ * ```
+ */
+export declare const toNumber: (value: Numbers) => number | bigint;
+/**
+ * Auto converts any given value into it's bigint representation
+ *
+ * @param value - The value to convert
+ * @returns - Returns the value in bigint representation
+
+ * @example
+ * ```ts
+ * console.log(web3.utils.toBigInt(1));
+ * > 1n
+ * ```
+ */
+export declare const toBigInt: (value: unknown) => bigint;
+/**
+ * Takes a number of wei and converts it to any other ether unit.
+ * @param number - The value in wei
+ * @param unit - The unit to convert to
+ * @returns - Returns the converted value in the given unit
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.fromWei("1", "ether"));
+ * > 0.000000000000000001
+ *
+ * console.log(web3.utils.fromWei("1", "shannon"));
+ * > 0.000000001
+ * ```
+ */
+export declare const fromWei: (number: Numbers, unit: EtherUnits | number) => string;
+/**
+ * Takes a number of a unit and converts it to wei.
+ *
+ * @param number - The number to convert.
+ * @param unit - {@link EtherUnits} The unit of the number passed.
+ * @returns The number converted to wei.
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.toWei("0.001", "ether"));
+ * > 1000000000000000 //(wei)
+ * ```
+ */
+export declare const toWei: (number: Numbers, unit: EtherUnits | number) => string;
+/**
+ * Will convert an upper or lowercase Ethereum address to a checksum address.
+ * @param address - An address string
+ * @returns	The checksum address
+ * @example
+ * ```ts
+ * web3.utils.toChecksumAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
+ * > "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d"
+ * ```
+ */
+export declare const toChecksumAddress: (address: Address) => string;
+export declare const toBool: (value: boolean | string | number | unknown) => boolean;
+//# sourceMappingURL=converters.d.ts.map

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

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

package/lib/types/event_emitter.d.ts

@@ -0,0 +1,11 @@
+import EventEmitter3 from 'eventemitter3';
+/**
+ * This class copy the behavior of Node.js EventEmitter class.
+ * It is used to provide the same interface for the browser environment.
+ */
+export declare class EventEmitter extends EventEmitter3 {
+    private maxListeners;
+    setMaxListeners(maxListeners: number): this;
+    getMaxListeners(): number;
+}
+//# sourceMappingURL=event_emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event_emitter.d.ts","sourceRoot":"","sources":["../../src/event_emitter.ts"],"names":[],"mappings":"AAkBA,OAAO,aAAa,MAAM,eAAe,CAAC;AAE1C;;;GAGG;AACH,qBAAa,YAAa,SAAQ,aAAa;IAE9C,OAAO,CAAC,YAAY,CAA2B;IAExC,eAAe,CAAC,YAAY,EAAE,MAAM;IAKpC,eAAe,IAAI,MAAM;CAGhC"}

package/lib/types/formatter.d.ts

@@ -0,0 +1,44 @@
+import { DataFormat, FormatType } from 'web3-types';
+import { JsonSchema, ValidationSchemaInput } from 'web3-validator';
+export declare const isDataFormat: (dataFormat: unknown) => dataFormat is DataFormat;
+/**
+ * Converts a value depending on the format
+ * @param value - value to convert
+ * @param ethType - The type of the value to be parsed
+ * @param format - The format to be converted to
+ * @returns - The value converted to the specified format
+ */
+export declare const convertScalarValue: (value: unknown, ethType: string, format: DataFormat) => unknown;
+/**
+ * Converts the data to the specified format
+ * @param data - data to convert
+ * @param schema - The JSON schema that describes the structure of the data
+ * @param dataPath - A string array that specifies the path to the data within the JSON schema
+ * @param format  - The format to be converted to
+ * @param oneOfPath - An optional array of two-element tuples that specifies the "oneOf" option to choose, if the schema has oneOf and the data path can match multiple subschemas
+ * @returns - The data converted to the specified format
+ */
+export declare const convert: (data: Record<string, unknown> | unknown[] | unknown, schema: JsonSchema, dataPath: string[], format: DataFormat, oneOfPath?: [string, number][]) => unknown;
+/**
+ * Given data that can be interpreted according to the provided schema, returns equivalent data that has been formatted
+ * according to the provided return format.
+ *
+ * @param schema - how to interpret the data
+ * @param data - data to be formatted
+ * @param returnFormat - how to format the data
+ * @returns - formatted data
+ *
+ * @example
+ *
+ * ```js
+ * import { FMT_NUMBER, utils } from "web3";
+ *
+ * console.log(
+ *   utils.format({ format: "uint" }, "221", { number: FMT_NUMBER.HEX }),
+ * );
+ * // 0xdd
+ * ```
+ *
+ */
+export declare const format: <DataType extends unknown, ReturnType_1 extends DataFormat>(schema: ValidationSchemaInput | JsonSchema, data: DataType, returnFormat?: ReturnType_1) => FormatType<DataType, ReturnType_1>;
+//# sourceMappingURL=formatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/formatter.ts"],"names":[],"mappings":"AAiBA,OAAO,EAEN,UAAU,EAGV,UAAU,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAuB,UAAU,EAAS,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAQ/F,eAAO,MAAM,YAAY,eAAgB,OAAO,6BAI1B,CAAC;AAkDvB;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,UAAW,OAAO,WAAW,MAAM,UAAU,UAAU,YAkDrF,CAAC;AA8GF;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,SACb,OAAO,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,GAAG,OAAO,UAC3C,UAAU,YACR,MAAM,EAAE,UACV,UAAU,cACP,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,YAiF7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,MAAM,sEAIV,qBAAqB,GAAG,UAAU,oFAyB1C,CAAC"}

package/lib/types/hash.d.ts

@@ -0,0 +1,94 @@
+import { Bytes, Numbers, Sha3Input, TypedObject, TypedObjectAbbreviated } from 'web3-types';
+/**
+ * A wrapper for ethereum-cryptography/keccak256 to allow hashing a `string` and a `bigint` in addition to `UInt8Array`
+ * @param data - the input to hash
+ * @returns - the Keccak-256 hash of the input
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.keccak256Wrapper('web3.js'));
+ * > 0x63667efb1961039c9bb0d6ea7a5abdd223a3aca7daa5044ad894226e1f83919a
+ *
+ * console.log(web3.utils.keccak256Wrapper(1));
+ * > 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6
+ *
+ * console.log(web3.utils.keccak256Wrapper(0xaf12fd));
+ * > 0x358640fd4719fa923525d74ab5ae80a594301aba5543e3492b052bf4598b794c
+ * ```
+ */
+export declare const keccak256Wrapper: (data: Bytes | Numbers | string | ReadonlyArray<number>) => string;
+export { keccak256Wrapper as keccak256 };
+/**
+ * computes the Keccak-256 hash of the input and returns a hexstring
+ * @param data - the input to hash
+ * @returns - the Keccak-256 hash of the input
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.sha3('web3.js'));
+ * > 0x63667efb1961039c9bb0d6ea7a5abdd223a3aca7daa5044ad894226e1f83919a
+ *
+ * console.log(web3.utils.sha3(''));
+ * > undefined
+ * ```
+ */
+export declare const sha3: (data: Bytes) => string | undefined;
+/**
+ * Will calculate the sha3 of the input but does return the hash value instead of null if for example a empty string is passed.
+ * @param data - the input to hash
+ * @returns - the Keccak-256 hash of the input
+ *
+ * @example
+ * ```ts
+ * conosle.log(web3.utils.sha3Raw('web3.js'));
+ * > 0x63667efb1961039c9bb0d6ea7a5abdd223a3aca7daa5044ad894226e1f83919a
+ *
+ * console.log(web3.utils.sha3Raw(''));
+ * > 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+ * ```
+ */
+export declare const sha3Raw: (data: Bytes) => string;
+/**
+ * returns a string of the tightly packed value given based on the type
+ * @param arg - the input to return the tightly packed value
+ * @returns - the tightly packed value
+ */
+export declare const processSolidityEncodePackedArgs: (arg: Sha3Input) => string;
+/**
+ * Encode packed arguments to a hexstring
+ */
+export declare const encodePacked: (...values: Sha3Input[]) => string;
+/**
+ * Will tightly pack values given in the same way solidity would then hash.
+ * returns a hash string, or null if input is empty
+ * @param values - the input to return the tightly packed values
+ * @returns - the keccack246 of the tightly packed values
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.soliditySha3({ type: "string", value: "31323334" }));
+ * > 0xf15f8da2ad27e486d632dc37d24912f634398918d6f9913a0a0ff84e388be62b
+ * ```
+ */
+export declare const soliditySha3: (...values: Sha3Input[]) => string | undefined;
+/**
+ * Will tightly pack values given in the same way solidity would then hash.
+ * returns a hash string, if input is empty will return `0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470`
+ * @param values - the input to return the tightly packed values
+ * @returns - the keccack246 of the tightly packed values
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.soliditySha3Raw({ type: "string", value: "helloworld" }))
+ * > 0xfa26db7ca85ead399216e7c6316bc50ed24393c3122b582735e7f3b0f91b93f0
+ * ```
+ */
+export declare const soliditySha3Raw: (...values: TypedObject[] | TypedObjectAbbreviated[]) => string;
+/**
+ * Get slot number for storage long string in contract. Basically for getStorage method
+ * returns slotNumber where will data placed
+ * @param mainSlotNumber - the slot number where will be stored hash of long string
+ * @returns - the slot number where will be stored long string
+ */
+export declare const getStorageSlotNumForLongString: (mainSlotNumber: number | string) => string | undefined;
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AAqDA,OAAO,EACN,KAAK,EAEL,OAAO,EACP,SAAS,EACT,WAAW,EACX,sBAAsB,EACtB,MAAM,YAAY,CAAC;AAepB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,SACtB,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,cAAc,MAAM,CAAC,KACpD,MAYF,CAAC;AAEF,OAAO,EAAE,gBAAgB,IAAI,SAAS,EAAE,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,SAAU,KAAK,KAAG,MAAM,GAAG,SAgB3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,SAAU,KAAK,KAAG,MAOrC,CAAC;AAqKF;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,QAAS,SAAS,KAAG,MAYhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,cAAe,SAAS,EAAE,KAAG,MAGrD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,cAAe,SAAS,EAAE,KAAG,MAAM,GAAG,SACjC,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,cAAe,WAAW,EAAE,GAAG,sBAAsB,EAAE,KAAG,MACrD,CAAC;AAElC;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,mBAAoB,MAAM,GAAG,MAAM,uBAM5E,CAAC"}

package/lib/types/index.d.ts

@@ -0,0 +1,19 @@
+export * from './converters.js';
+export * from './event_emitter.js';
+export * from './validation.js';
+export * from './formatter.js';
+export * from './hash.js';
+export * from './random.js';
+export * from './string_manipulation.js';
+export * from './objects.js';
+export * from './promise_helpers.js';
+export * from './json_rpc.js';
+export * as jsonRpc from './json_rpc.js';
+export * from './web3_deferred_promise.js';
+export * from './chunk_response_parser.js';
+export * from './uuid.js';
+export * from './web3_eip1193_provider.js';
+export * from './socket_provider.js';
+export * from './uint8array.js';
+export { AbiItem } from 'web3-types';
+//# 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,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,WAAW,CAAC;AAC1B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/lib/types/json_rpc.d.ts

@@ -0,0 +1,22 @@
+import { JsonRpcPayload, JsonRpcResponse, JsonRpcResponseWithResult, JsonRpcResponseWithError, JsonRpcOptionalRequest, JsonRpcBatchRequest, JsonRpcNotification, JsonRpcRequest, JsonRpcBatchResponse, JsonRpcSubscriptionResult } from 'web3-types';
+export declare const isResponseRpcError: (rpcError: JsonRpcResponseWithError) => boolean;
+export declare const isResponseWithResult: <Result = unknown, Error_1 = unknown>(response: JsonRpcResponse<Result, Error_1>) => response is JsonRpcResponseWithResult<Result>;
+export declare const isResponseWithError: <Error_1 = unknown, Result = unknown>(response: JsonRpcResponse<Result, Error_1>) => response is JsonRpcResponseWithError<Error_1>;
+export declare const isResponseWithNotification: <Result>(response: JsonRpcNotification<Result> | JsonRpcSubscriptionResult) => response is JsonRpcNotification<Result>;
+export declare const isSubscriptionResult: <Result>(response: JsonRpcSubscriptionResult | JsonRpcNotification<Result>) => response is JsonRpcSubscriptionResult;
+export declare const validateResponse: <Result = unknown, Error_1 = unknown>(response: JsonRpcResponse<Result, Error_1>) => boolean;
+export declare const isValidResponse: <Result = unknown, Error_1 = unknown>(response: JsonRpcResponse<Result, Error_1>) => boolean;
+export declare const isBatchResponse: <Result = unknown, Error_1 = unknown>(response: JsonRpcResponse<Result, Error_1>) => response is JsonRpcBatchResponse<Result, Error_1>;
+/**
+ * Optionally use to make the jsonrpc `id` start from a specific number.
+ * Without calling this function, the `id` will be filled with a Uuid.
+ * But after this being called with a number, the `id` will be a number starting from the provided `start` variable.
+ * However, if `undefined` was passed to this function, the `id` will be a Uuid again.
+ * @param start - a number to start incrementing from.
+ * 	Or `undefined` to use a new Uuid (this is the default behavior)
+ */
+export declare const setRequestIdStart: (start: number | undefined) => void;
+export declare const toPayload: <ParamType = unknown[]>(request: JsonRpcOptionalRequest<ParamType>) => JsonRpcPayload<ParamType>;
+export declare const toBatchPayload: (requests: JsonRpcOptionalRequest<unknown>[]) => JsonRpcBatchRequest;
+export declare const isBatchRequest: (request: JsonRpcBatchRequest | JsonRpcRequest<unknown> | JsonRpcOptionalRequest<unknown>) => request is JsonRpcBatchRequest;
+//# sourceMappingURL=json_rpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json_rpc.d.ts","sourceRoot":"","sources":["../../src/json_rpc.ts"],"names":[],"mappings":"AAkBA,OAAO,EACN,cAAc,EACd,eAAe,EACf,yBAAyB,EACzB,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,yBAAyB,EACzB,MAAM,YAAY,CAAC;AAKpB,eAAO,MAAM,kBAAkB,aAAc,wBAAwB,YAGpE,CAAC;AAEF,eAAO,MAAM,oBAAoB,oIASoC,CAAC;AAGtE,eAAO,MAAM,mBAAmB,oIASqC,CAAC;AAEtE,eAAO,MAAM,0BAA0B,wHAOX,CAAC;AAE7B,eAAO,MAAM,oBAAoB,sHAQZ,CAAC;AAEtB,eAAO,MAAM,gBAAgB,uFAE1B,OAAyF,CAAC;AAE7F,eAAO,MAAM,eAAe,uFAEzB,OACqF,CAAC;AAEzF,eAAO,MAAM,eAAe,wIAGgD,CAAC;AAK7E;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,UAAW,MAAM,GAAG,SAAS,SAE1D,CAAC;AAEF,eAAO,MAAM,SAAS,kGAYrB,CAAC;AAEF,eAAO,MAAM,cAAc,aAAc,uBAAuB,OAAO,CAAC,EAAE,wBACE,CAAC;AAE7E,eAAO,MAAM,cAAc,YACjB,mBAAmB,GAAG,eAAe,OAAO,CAAC,GAAG,uBAAuB,OAAO,CAAC,mCACR,CAAC"}

package/lib/types/objects.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Deep merge two objects.
+ * @param destination - The destination object.
+ * @param sources - An array of source objects.
+ * @returns - The merged object.
+ */
+export declare const mergeDeep: (destination: Record<string, unknown>, ...sources: Record<string, unknown>[]) => Record<string, unknown>;
+//# sourceMappingURL=objects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/objects.ts"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,gBACR,OAAO,MAAM,EAAE,OAAO,CAAC,cACxB,OAAO,MAAM,EAAE,OAAO,CAAC,EAAE,KACnC,OAAO,MAAM,EAAE,OAAO,CA2BxB,CAAC"}

package/lib/types/promise_helpers.d.ts

@@ -0,0 +1,48 @@
+export declare type Timer = ReturnType<typeof setInterval>;
+export declare type Timeout = ReturnType<typeof setTimeout>;
+/**
+ * An alternative to the node function `isPromise` that exists in `util/types` because it is not available on the browser.
+ * @param object - to check if it is a `Promise`
+ * @returns `true` if it is an `object` or a `function` that has a `then` function. And returns `false` otherwise.
+ */
+export declare function isPromise(object: unknown): boolean;
+export declare type AsyncFunction<T, K = unknown> = (...args: K[]) => Promise<T>;
+export declare function waitWithTimeout<T>(awaitable: Promise<T> | AsyncFunction<T>, timeout: number, error: Error): Promise<T>;
+export declare function waitWithTimeout<T>(awaitable: Promise<T> | AsyncFunction<T>, timeout: number): Promise<T | undefined>;
+/**
+ * Repeatedly calls an async function with a given interval until the result of the function is defined (not undefined or null),
+ * or until a timeout is reached. It returns promise and intervalId.
+ * @param func - The function to call.
+ * @param interval - The interval in milliseconds.
+ */
+export declare function pollTillDefinedAndReturnIntervalId<T>(func: AsyncFunction<T>, interval: number): [Promise<Exclude<T, undefined>>, Timer];
+/**
+ * Repeatedly calls an async function with a given interval until the result of the function is defined (not undefined or null),
+ * or until a timeout is reached.
+ * pollTillDefinedAndReturnIntervalId() function should be used instead of pollTillDefined if you need IntervalId in result.
+ * This function will be deprecated in next major release so use pollTillDefinedAndReturnIntervalId().
+ * @param func - The function to call.
+ * @param interval - The interval in milliseconds.
+ */
+export declare function pollTillDefined<T>(func: AsyncFunction<T>, interval: number): Promise<Exclude<T, undefined>>;
+/**
+ * Enforce a timeout on a promise, so that it can be rejected if it takes too long to complete
+ * @param timeout - The timeout to enforced in milliseconds.
+ * @param error - The error to throw if the timeout is reached.
+ * @returns A tuple of the timeout id and the promise that will be rejected if the timeout is reached.
+ *
+ * @example
+ * ```ts
+ * const [timerId, promise] = web3.utils.rejectIfTimeout(100, new Error('time out'));
+ * ```
+ */
+export declare function rejectIfTimeout(timeout: number, error: Error): [Timer, Promise<never>];
+/**
+ * Sets an interval that repeatedly executes the given cond function with the specified interval between each call.
+ * If the condition is met, the interval is cleared and a Promise that rejects with the returned value is returned.
+ * @param cond - The function/condition to call.
+ * @param interval - The interval in milliseconds.
+ * @returns - an array with the interval ID and the Promise.
+ */
+export declare function rejectIfConditionAtInterval<T>(cond: AsyncFunction<T | undefined>, interval: number): [Timer, Promise<never>];
+//# sourceMappingURL=promise_helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promise_helpers.d.ts","sourceRoot":"","sources":["../../src/promise_helpers.ts"],"names":[],"mappings":"AAmBA,oBAAY,KAAK,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AACnD,oBAAY,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED,oBAAY,aAAa,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAEzE,wBAAgB,eAAe,CAAC,CAAC,EAChC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GACV,OAAO,CAAC,CAAC,CAAC,CAAC;AACd,wBAAgB,eAAe,CAAC,CAAC,EAChC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AA8B1B;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,CAAC,EACnD,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,MAAM,GACd,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,CAyBzC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACtC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAEhC;AACD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAQtF;AACD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC5C,IAAI,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC,EAClC,QAAQ,EAAE,MAAM,GACd,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAczB"}

package/lib/types/random.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns a random byte array by the given bytes size
+ * @param size - The size of the random byte array returned
+ * @returns - random byte array
+ *
+ * @example
+ * ```ts
+ * console.log(web3.utils.randomBytes(32));
+ * > Uint8Array(32) [
+ *       93, 172, 226,  32,  33, 176, 156, 156,
+ *       182,  30, 240,   2,  69,  96, 174, 197,
+ *       33, 136, 194, 241, 197, 156, 110, 111,
+ *       66,  87,  17,  88,  67,  48, 245, 183
+ *    ]
+ * ```
+ */
+export declare const randomBytes: (size: number) => Uint8Array;
+/**
+ * Returns a random hex string by the given bytes size
+ * @param byteSize - The size of the random hex string returned
+ * @returns - random hex string
+ *
+ * ```ts
+ * console.log(web3.utils.randomHex(32));
+ * > 0x139f5b88b72a25eab053d3b57fe1f8a9dbc62a526b1cb1774d0d7db1c3e7ce9e
+ * ```
+ */
+export declare const randomHex: (byteSize: number) => string;
+//# sourceMappingURL=random.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/random.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,KAAG,UAAsC,CAAC;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,aAAc,MAAM,KAAG,MAA2C,CAAC"}