web3util 4.3.2

package/src/event_emitter.ts

@@ -0,0 +1,37 @@
+/*
+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/>.
+*/
+/* eslint-disable max-classes-per-file */
+
+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 class EventEmitter extends EventEmitter3 {
+	// must be defined for backwards compatibility
+	private maxListeners = Number.MAX_SAFE_INTEGER;
+
+	public setMaxListeners(maxListeners: number) {
+		this.maxListeners = maxListeners;
+		return this;
+	}
+
+	public getMaxListeners(): number {
+		return this.maxListeners;
+	}
+}

package/src/formatter.ts

@@ -0,0 +1,402 @@
+/*
+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 { FormatterError } from 'web3-errors';
+import {
+	Bytes,
+	DataFormat,
+	FMT_BYTES,
+	FMT_NUMBER,
+	FormatType,
+	DEFAULT_RETURN_FORMAT,
+} from 'web3-types';
+import { isNullish, isObject, JsonSchema, utils, ValidationSchemaInput } from 'web3-validator';
+import { bytesToUint8Array, bytesToHex, numberToHex, toBigInt } from './converters.js';
+import { mergeDeep } from './objects.js';
+import { padLeft } from './string_manipulation.js';
+import { isUint8Array, uint8ArrayConcat } from './uint8array.js';
+
+const { parseBaseType } = utils;
+
+export const isDataFormat = (dataFormat: unknown): dataFormat is DataFormat =>
+	typeof dataFormat === 'object' &&
+	!isNullish(dataFormat) &&
+	'number' in dataFormat &&
+	'bytes' in dataFormat;
+
+/**
+ * Finds the schema that corresponds to a specific data path within a larger JSON schema.
+ * It works by iterating over the dataPath array and traversing the JSON schema one step at a time until it reaches the end of the path.
+ *
+ * @param schema - represents a JSON schema, which is an object that describes the structure of JSON data
+ * @param dataPath - represents an array of strings that specifies the path to the data within the JSON schema
+ * @param oneOfPath - represents 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 JSON schema that matches the data path
+ *
+ */
+const findSchemaByDataPath = (
+	schema: JsonSchema,
+	dataPath: string[],
+	oneOfPath: [string, number][] = [],
+): JsonSchema | undefined => {
+	let result: JsonSchema = { ...schema } as JsonSchema;
+	let previousDataPath: string | undefined;
+
+	for (const dataPart of dataPath) {
+		if (result.oneOf && previousDataPath) {
+			const currentDataPath = previousDataPath;
+			const path = oneOfPath.find(([key]) => key === currentDataPath);
+			if (path && path[0] === previousDataPath) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+				result = result.oneOf[path[1]];
+			}
+		}
+		if (!result.properties && !result.items) {
+			return undefined;
+		}
+
+		if (result.properties) {
+			result = (result.properties as Record<string, JsonSchema>)[dataPart];
+		} else if (result.items && (result.items as JsonSchema).properties) {
+			const node = (result.items as JsonSchema).properties as Record<string, JsonSchema>;
+
+			result = node[dataPart];
+		} else if (result.items && isObject(result.items)) {
+			result = result.items;
+		} else if (result.items && Array.isArray(result.items)) {
+			result = result.items[parseInt(dataPart, 10)];
+		}
+
+		if (result && dataPart) previousDataPath = dataPart;
+	}
+
+	return result;
+};
+/**
+ * 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 const convertScalarValue = (value: unknown, ethType: string, format: DataFormat) => {
+	try {
+		const { baseType, baseTypeSize } = parseBaseType(ethType);
+		if (baseType === 'int' || baseType === 'uint') {
+			switch (format.number) {
+				case FMT_NUMBER.NUMBER:
+					return Number(toBigInt(value));
+				case FMT_NUMBER.HEX:
+					return numberToHex(toBigInt(value));
+				case FMT_NUMBER.STR:
+					return toBigInt(value).toString();
+				case FMT_NUMBER.BIGINT:
+					return toBigInt(value);
+				default:
+					throw new FormatterError(`Invalid format: ${String(format.number)}`);
+			}
+		}
+		if (baseType === 'bytes') {
+			let paddedValue;
+			if (baseTypeSize) {
+				if (typeof value === 'string') paddedValue = padLeft(value, baseTypeSize * 2);
+				else if (isUint8Array(value)) {
+					paddedValue = uint8ArrayConcat(
+						new Uint8Array(baseTypeSize - value.length),
+						value,
+					);
+				}
+			} else {
+				paddedValue = value;
+			}
+			switch (format.bytes) {
+				case FMT_BYTES.HEX:
+					return bytesToHex(bytesToUint8Array(paddedValue as Bytes));
+				case FMT_BYTES.UINT8ARRAY:
+					return bytesToUint8Array(paddedValue as Bytes);
+				default:
+					throw new FormatterError(`Invalid format: ${String(format.bytes)}`);
+			}
+		}
+
+		if (baseType === 'string') {
+			return String(value);
+		}
+	} catch (error) {
+		// If someone didn't use `eth` keyword we can return original value
+		// as the scope of this code is formatting not validation
+		return value;
+	}
+
+	return value;
+};
+
+const convertArray = ({
+	value,
+	schemaProp,
+	schema,
+	object,
+	key,
+	dataPath,
+	format,
+	oneOfPath = [],
+}: {
+	value: unknown;
+	schemaProp: JsonSchema;
+	schema: JsonSchema;
+	object: Record<string, unknown>;
+	key: string;
+	dataPath: string[];
+	format: DataFormat;
+	oneOfPath: [string, number][];
+}) => {
+	// If value is an array
+	if (Array.isArray(value)) {
+		let _schemaProp = schemaProp;
+
+		// TODO This is a naive approach to solving the issue of
+		// a schema using oneOf. This chunk of code was intended to handle
+		// BlockSchema.transactions
+		// TODO BlockSchema.transactions are not being formatted
+		if (schemaProp?.oneOf !== undefined) {
+			// The following code is basically saying:
+			// if the schema specifies oneOf, then we are to loop
+			// over each possible schema and check if they type of the schema
+			// matches the type of value[0], and if so we use the oneOfSchemaProp
+			// as the schema for formatting
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+			schemaProp.oneOf.forEach((oneOfSchemaProp: JsonSchema, index: number) => {
+				if (
+					!Array.isArray(schemaProp?.items) &&
+					((typeof value[0] === 'object' &&
+						(oneOfSchemaProp?.items as JsonSchema)?.type === 'object') ||
+						(typeof value[0] === 'string' &&
+							(oneOfSchemaProp?.items as JsonSchema)?.type !== 'object'))
+				) {
+					_schemaProp = oneOfSchemaProp;
+					oneOfPath.push([key, index]);
+				}
+			});
+		}
+
+		if (isNullish(_schemaProp?.items)) {
+			// Can not find schema for array item, delete that item
+			// eslint-disable-next-line no-param-reassign
+			delete object[key];
+			dataPath.pop();
+
+			return true;
+		}
+
+		// If schema for array items is a single type
+		if (isObject(_schemaProp.items) && !isNullish(_schemaProp.items.format)) {
+			for (let i = 0; i < value.length; i += 1) {
+				// eslint-disable-next-line no-param-reassign
+				(object[key] as unknown[])[i] = convertScalarValue(
+					value[i],
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+					_schemaProp?.items?.format,
+					format,
+				);
+			}
+
+			dataPath.pop();
+			return true;
+		}
+
+		// If schema for array items is an object
+		if (!Array.isArray(_schemaProp?.items) && _schemaProp?.items?.type === 'object') {
+			for (const arrObject of value) {
+				// eslint-disable-next-line no-use-before-define
+				convert(
+					arrObject as Record<string, unknown> | unknown[],
+					schema,
+					dataPath,
+					format,
+					oneOfPath,
+				);
+			}
+
+			dataPath.pop();
+			return true;
+		}
+
+		// If schema for array is a tuple
+		if (Array.isArray(_schemaProp?.items)) {
+			for (let i = 0; i < value.length; i += 1) {
+				// eslint-disable-next-line no-param-reassign
+				(object[key] as unknown[])[i] = convertScalarValue(
+					value[i],
+					_schemaProp.items[i].format as string,
+					format,
+				);
+			}
+
+			dataPath.pop();
+			return true;
+		}
+	}
+	return false;
+};
+
+/**
+ * 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 const convert = (
+	data: Record<string, unknown> | unknown[] | unknown,
+	schema: JsonSchema,
+	dataPath: string[],
+	format: DataFormat,
+	oneOfPath: [string, number][] = [],
+) => {
+	// If it's a scalar value
+	if (!isObject(data) && !Array.isArray(data)) {
+		return convertScalarValue(data, schema?.format as string, format);
+	}
+
+	const object = data as Record<string, unknown>;
+	// case when schema is array and `items` is object
+	if (
+		Array.isArray(object) &&
+		schema?.type === 'array' &&
+		(schema?.items as JsonSchema)?.type === 'object'
+	) {
+		convertArray({
+			value: object,
+			schemaProp: schema,
+			schema,
+			object,
+			key: '',
+			dataPath,
+			format,
+			oneOfPath,
+		});
+	} else {
+		for (const [key, value] of Object.entries(object)) {
+			dataPath.push(key);
+			let schemaProp = findSchemaByDataPath(schema, dataPath, oneOfPath);
+
+			// If value is a scaler value
+			if (isNullish(schemaProp)) {
+				delete object[key];
+				dataPath.pop();
+
+				continue;
+			}
+
+			// If value is an object, recurse into it
+			if (isObject(value)) {
+				convert(value, schema, dataPath, format, oneOfPath);
+				dataPath.pop();
+				continue;
+			}
+
+			// If value is an array
+			if (
+				convertArray({
+					value,
+					schemaProp,
+					schema,
+					object,
+					key,
+					dataPath,
+					format,
+					oneOfPath,
+				})
+			) {
+				continue;
+			}
+
+			// The following code is basically saying:
+			// if the schema specifies oneOf, then we are to loop
+			// over each possible schema and check if they type of the schema specifies format
+			// and if so we use the oneOfSchemaProp as the schema for formatting
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+			if (schemaProp?.format === undefined && schemaProp?.oneOf !== undefined) {
+				for (const [_index, oneOfSchemaProp] of schemaProp.oneOf.entries()) {
+					if (oneOfSchemaProp?.format !== undefined) {
+						schemaProp = oneOfSchemaProp;
+						break;
+					}
+				}
+			}
+
+			object[key] = convertScalarValue(value, schemaProp.format as string, format);
+
+			dataPath.pop();
+		}
+	}
+
+	return object;
+};
+
+/**
+ * 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 const format = <
+	DataType extends Record<string, unknown> | unknown[] | unknown,
+	ReturnType extends DataFormat,
+>(
+	schema: ValidationSchemaInput | JsonSchema,
+	data: DataType,
+	returnFormat: ReturnType = DEFAULT_RETURN_FORMAT as ReturnType,
+): FormatType<DataType, ReturnType> => {
+	let dataToParse: Record<string, unknown> | unknown[] | unknown;
+
+	if (isObject(data)) {
+		dataToParse = mergeDeep({}, data);
+	} else if (Array.isArray(data)) {
+		dataToParse = [...data];
+	} else {
+		dataToParse = data;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+	const jsonSchema: JsonSchema = isObject(schema) ? schema : utils.ethAbiToJsonSchema(schema);
+
+	if (!jsonSchema.properties && !jsonSchema.items && !jsonSchema.format) {
+		throw new FormatterError('Invalid json schema for formatting');
+	}
+
+	return convert(dataToParse, jsonSchema, [], returnFormat) as FormatType<
+		typeof data,
+		ReturnType
+	>;
+};