update formatter (#6068)

* update formatter

* update convertscalar method

* update schema

* update schema

* update padding format and tests

* remove arraybuffer from byte types

* remove else conditional

* update formatter unit tests

Author: Alex

packages/web3-eth/src/rpc_method_wrappers.ts

@@ -257,7 +257,6 @@ export async function getBlock<ReturnFormat extends DataFormat>(
 			hydrated,
 		);
 	}
-
 	return format(blockSchema, response as unknown as Block, returnFormat);
 }
 

packages/web3-eth/src/schemas.ts

@@ -158,10 +158,10 @@ export const transactionSchema = {
 			format: 'uint',
 		},
 		r: {
-			format: 'bytes',
+			format: 'bytes32',
 		},
 		s: {
-			format: 'bytes',
+			format: 'bytes32',
 		},
 	},
 };
@@ -228,10 +228,10 @@ export const transactionInfoSchema = {
 			format: 'uint',
 		},
 		r: {
-			format: 'bytes',
+			format: 'bytes32',
 		},
 		s: {
-			format: 'bytes',
+			format: 'bytes32',
 		},
 	},
 };

packages/web3-eth/test/unit/rpc_method_wrappers/get_block.test.ts

@@ -55,7 +55,6 @@ describe('getBlock', () => {
 			} else {
 				inputBlockFormatted = format({ format: 'uint' }, inputBlock, ETH_DATA_FORMAT);
 			}
-
 			await getBlock(web3Context, ...inputParameters, DEFAULT_RETURN_FORMAT);
 			expect(
 				inputBlockIsBytes ? ethRpcMethods.getBlockByHash : ethRpcMethods.getBlockByNumber,

packages/web3-types/src/primitives_types.ts

@@ -16,7 +16,7 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 export type HexString = string;
-export type Bytes = Uint8Array | ArrayBuffer | HexString;
+export type Bytes = Uint8Array | HexString;
 export type Numbers = number | bigint | string | HexString;
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment

packages/web3-utils/src/formatter.ts

@@ -19,6 +19,8 @@ import { Bytes, DataFormat, FMT_BYTES, FMT_NUMBER, FormatType } from 'web3-types
 import { isNullish, isObject, JsonSchema, utils, ValidationSchemaInput } from 'web3-validator';
 import { bytesToUint8Array, bytesToHex, numberToHex, toBigInt } from './converters';
 import { mergeDeep } from './objects';
+import { padLeft } from './string_manipulation';
+import { uint8ArrayConcat } from './uint8array';
 
 const { parseBaseType } = utils;
 
@@ -34,7 +36,7 @@ export const isDataFormat = (dataFormat: unknown): dataFormat is DataFormat =>
  *
  * @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 - epresents 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
+ * @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
  *
  */
@@ -91,8 +93,7 @@ const findSchemaByDataPath = (
  */
 export const convertScalarValue = (value: unknown, ethType: string, format: DataFormat) => {
 	try {
-		const { baseType } = parseBaseType(ethType);
-
+		const { baseType, baseTypeSize } = parseBaseType(ethType);
 		if (baseType === 'int' || baseType === 'uint') {
 			switch (format.number) {
 				case FMT_NUMBER.NUMBER:
@@ -107,13 +108,24 @@ export const convertScalarValue = (value: unknown, ethType: string, format: Data
 					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 (value instanceof Uint8Array) {
+					paddedValue = uint8ArrayConcat(
+						new Uint8Array(baseTypeSize - value.length),
+						value,
+					);
+				}
+			} else {
+				paddedValue = value;
+			}
 			switch (format.bytes) {
 				case FMT_BYTES.HEX:
-					return bytesToHex(bytesToUint8Array(value as Bytes));
+					return bytesToHex(bytesToUint8Array(paddedValue as Bytes));
 				case FMT_BYTES.UINT8ARRAY:
-					return bytesToUint8Array(value as Bytes);
+					return bytesToUint8Array(paddedValue as Bytes);
 				default:
 					throw new FormatterError(`Invalid format: ${String(format.bytes)}`);
 			}

packages/web3-utils/src/hash.ts

@@ -71,8 +71,6 @@ export const sha3 = (data: Bytes): string | undefined => {
 		} else {
 			updatedData = utf8ToBytes(data);
 		}
-	} else if (data instanceof ArrayBuffer || Array.isArray(data)) {
-		updatedData = new Uint8Array(data);
 	} else {
 		updatedData = data;
 	}

packages/web3-utils/test/fixtures/formatter.ts

@@ -24,17 +24,35 @@ export const isDataFormatValid: [any, boolean][] = [
 ];
 
 export const convertScalarValueValid: [[any, any, any], any][] = [
+	[[new Uint8Array(hexToBytes('FF')), 'bytes', { bytes: FMT_BYTES.HEX }], '0xff'],
+	[
+		[
+			'0xe84375b25f38de0e68f7f4884b7342e0814747143c790f48088d22e802cf7a3',
+			'bytes32',
+			{ bytes: FMT_BYTES.HEX },
+		],
+		'0x0e84375b25f38de0e68f7f4884b7342e0814747143c790f48088d22e802cf7a3',
+	],
 	[[100, 'int', { number: FMT_NUMBER.NUMBER, bytes: FMT_BYTES.HEX }], 100],
+	[[100, 'int', { number: 'unknown', bytes: FMT_BYTES.HEX }], 100],
 	[[100, 'uint', { number: FMT_NUMBER.HEX, bytes: FMT_BYTES.HEX }], '0x64'],
 	[[64, 'uint8', { number: FMT_NUMBER.STR }], '64'],
-
-	[[new Uint8Array(hexToBytes('FF')), 'bytes', { bytes: FMT_BYTES.HEX }], '0xff'],
 	[
 		[new Uint8Array(hexToBytes('FF')), 'bytes', { bytes: FMT_BYTES.UINT8ARRAY }],
 		new Uint8Array(new Uint8Array(hexToBytes('FF'))),
 	],
 	[
-		[new Uint8Array(hexToBytes('FF')), 'bytes', { bytes: FMT_BYTES }],
+		[new Uint8Array(hexToBytes('FF')), 'bytes32', { bytes: FMT_BYTES.HEX }],
+		'0x00000000000000000000000000000000000000000000000000000000000000ff',
+	],
+	[
+		[new Uint8Array(hexToBytes('FF')), 'unknown', { bytes: FMT_BYTES.HEX }],
 		new Uint8Array(hexToBytes('FF')),
 	],
+	[
+		[new Uint8Array(hexToBytes('FF')), 'bytes32', { bytes: FMT_BYTES.UINT8ARRAY }],
+		new Uint8Array(
+			hexToBytes('0x00000000000000000000000000000000000000000000000000000000000000ff'),
+		),
+	],
 ];

packages/web3-validator/src/types.ts

@@ -35,7 +35,7 @@ export type Web3ValidationErrorObject<
 	data?: unknown;
 };
 
-export type ValidInputTypes = ArrayBuffer | Uint8Array | bigint | string | number | boolean;
+export type ValidInputTypes = Uint8Array | bigint | string | number | boolean;
 export type EthBaseTypes = 'bool' | 'bytes' | 'string' | 'uint' | 'int' | 'address' | 'tuple';
 export type EthBaseTypesWithMeta =
 	| `string${string}`

packages/web3-validator/test/fixtures/validation.ts

@@ -297,7 +297,6 @@ export const validStringNumbersWithHex: [string, string][] = [
 ];
 
 export const invalidStringNumbers: ValidInputTypes[] = [
-	new ArrayBuffer(23255),
 	new Uint8Array([0x97, 0x98, 0x99]),
 	new Uint8Array(hexToBytes('abcd')),
 ];