@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/packages/abi/src/abi-type.mjs

@@ -0,0 +1,675 @@
+import { concatArrays } from "../../common/src/array.mjs";
+import { BOOL_FALSE_BYTE, BOOL_TRUE_BYTE, LENGTH_ENCODE_BYTE_SIZE, PUBLIC_KEY_BYTE_LENGTH } from "../../common/src/constants.mjs";
+import { Address } from "../../common/src/address.mjs";
+import { bigIntToBytes, bytesToBigInt } from "./bigint.mjs";
+
+//#region packages/abi/src/abi-type.ts
+const STATIC_ARRAY_REGEX = /^([a-z\d[\](),]+)\[(0|[1-9][\d]*)]$/;
+const UFIXED_REGEX = /^ufixed([1-9][\d]*)x([1-9][\d]*)$/;
+const MAX_LEN = 2 ** 16 - 1;
+/**
+* Represents an Algorand ABI type for encoding and decoding values as defined in [ARC-0004](https://arc.algorand.foundation/ARCs/arc-0004#types).
+*
+* This is the abstract base class for all ABI types.
+*/
+var ABIType = class ABIType {
+	/**
+	* Returns a user-friendly display name for this type.
+	* @returns The display name for this type
+	*/
+	get displayName() {
+		return this.name;
+	}
+	/**
+	* Returns the ARC-4 type name string representation.
+	* @returns The ARC-4 type string
+	*/
+	toString() {
+		return this.name;
+	}
+	/**
+	* Creates an ABI type from an ARC-4 type string.
+	* @param str The ARC-4 type string (e.g., "uint256", "bool", "(uint8,address)")
+	* @returns The corresponding ABI type
+	*/
+	static from(str) {
+		if (str.endsWith("[]")) return new ABIArrayDynamicType(ABIType.from(str.slice(0, str.length - 2)));
+		if (str.endsWith("]")) {
+			const stringMatches = str.match(STATIC_ARRAY_REGEX);
+			if (!stringMatches || stringMatches.length !== 3) throw new Error(`Malformed static array string: ${str}`);
+			const arrayLengthStr = stringMatches[2];
+			const arrayLength = parseInt(arrayLengthStr, 10);
+			if (arrayLength > MAX_LEN) throw new Error(`Array length exceeds limit ${MAX_LEN}`);
+			return new ABIArrayStaticType(ABIType.from(stringMatches[1]), arrayLength);
+		}
+		if (str.startsWith("uint")) {
+			const digitsOnly = (s) => [...s].every((c) => "0123456789".includes(c));
+			const typeSizeStr = str.slice(4, str.length);
+			if (!digitsOnly(typeSizeStr)) throw new Error(`Malformed uint string: ${typeSizeStr}`);
+			const bitSize = parseInt(typeSizeStr, 10);
+			if (bitSize > MAX_LEN) throw new Error(`Malformed uint string: ${bitSize}`);
+			return new ABIUintType(bitSize);
+		}
+		if (str === "byte") return new ABIByteType();
+		if (str.startsWith("ufixed")) {
+			const stringMatches = str.match(UFIXED_REGEX);
+			if (!stringMatches || stringMatches.length !== 3) throw new Error(`Malformed ufixed type: ${str}`);
+			return new ABIUfixedType(parseInt(stringMatches[1], 10), parseInt(stringMatches[2], 10));
+		}
+		if (str === "bool") return new ABIBoolType();
+		if (str === "address") return new ABIAddressType();
+		if (str === "string") return new ABIStringType();
+		if (str.length >= 2 && str[0] === "(" && str[str.length - 1] === ")") {
+			const tupleContent = parseTupleContent(str.slice(1, str.length - 1));
+			const childTypes = [];
+			for (let i = 0; i < tupleContent.length; i++) {
+				const ti = ABIType.from(tupleContent[i]);
+				childTypes.push(ti);
+			}
+			return new ABITupleType(childTypes);
+		}
+		throw new Error(`Cannot convert a string ${str} to an ABI type`);
+	}
+};
+/**
+* An unsigned integer ABI type of a specific bit size.
+*/
+var ABIUintType = class ABIUintType extends ABIType {
+	/**
+	* Creates a new unsigned integer type.
+	* @param bitSize The bit size (must be a multiple of 8, between 8 and 512)
+	*/
+	constructor(bitSize) {
+		super();
+		this.bitSize = bitSize;
+		if (bitSize % 8 !== 0 || bitSize < 8 || bitSize > 512) throw new Error(`Unsupported uint type bitSize: ${bitSize}`);
+	}
+	get name() {
+		return `uint${this.bitSize}`;
+	}
+	equals(other) {
+		return other instanceof ABIUintType && this.bitSize === other.bitSize;
+	}
+	isDynamic() {
+		return false;
+	}
+	byteLen() {
+		return this.bitSize / 8;
+	}
+	encode(value) {
+		if (typeof value !== "bigint" && typeof value !== "number") throw new Error(`Cannot encode value as ${this.name}: ${value}`);
+		if (value >= BigInt(2 ** this.bitSize) || value < BigInt(0)) throw new Error(`${value} is not a non-negative int or too big to fit in size ${this.name}`);
+		if (typeof value === "number" && !Number.isSafeInteger(value)) throw new Error(`${value} should be converted into a BigInt before it is encoded`);
+		return bigIntToBytes(value, this.bitSize / 8);
+	}
+	decode(bytes) {
+		if (bytes.length !== this.bitSize / 8) throw new Error(`Byte string must correspond to a ${this.name}`);
+		const value = bytesToBigInt(bytes);
+		return this.bitSize < 53 ? Number(value) : value;
+	}
+};
+/**
+* A fixed-point number ABI type of a specific bit size and precision.
+*/
+var ABIUfixedType = class ABIUfixedType extends ABIType {
+	/**
+	* Creates a new fixed-point type.
+	* @param bitSize The bit size (must be a multiple of 8, between 8 and 512)
+	* @param precision The decimal precision (must be between 1 and 160)
+	*/
+	constructor(bitSize, precision) {
+		super();
+		this.bitSize = bitSize;
+		this.precision = precision;
+		if (bitSize % 8 !== 0 || bitSize < 8 || bitSize > 512) throw new Error(`Unsupported ufixed type bitSize: ${bitSize}`);
+		if (precision > 160 || precision < 1) throw new Error(`Unsupported ufixed type precision: ${precision}`);
+	}
+	get name() {
+		return `ufixed${this.bitSize}x${this.precision}`;
+	}
+	equals(other) {
+		return other instanceof ABIUfixedType && this.bitSize === other.bitSize && this.precision === other.precision;
+	}
+	isDynamic() {
+		return false;
+	}
+	byteLen() {
+		return this.bitSize / 8;
+	}
+	encode(value) {
+		if (typeof value !== "bigint" && typeof value !== "number") throw new Error(`Cannot encode value as ${this.name}: ${value}`);
+		if (value >= BigInt(2 ** this.bitSize) || value < BigInt(0)) throw new Error(`${value} is not a non-negative int or too big to fit in size ${this.name}`);
+		if (typeof value === "number" && !Number.isSafeInteger(value)) throw new Error(`${value} should be converted into a BigInt before it is encoded`);
+		return bigIntToBytes(value, this.bitSize / 8);
+	}
+	decode(bytes) {
+		if (bytes.length !== this.bitSize / 8) throw new Error(`Byte string must correspond to a ${this.name}`);
+		const value = bytesToBigInt(bytes);
+		return this.bitSize < 53 ? Number(value) : value;
+	}
+};
+/**
+* An Algorand address ABI type.
+*/
+var ABIAddressType = class ABIAddressType extends ABIType {
+	get name() {
+		return "address";
+	}
+	equals(other) {
+		return other instanceof ABIAddressType;
+	}
+	isDynamic() {
+		return false;
+	}
+	byteLen() {
+		return PUBLIC_KEY_BYTE_LENGTH;
+	}
+	encode(value) {
+		if (typeof value === "string") return Address.fromString(value).publicKey;
+		if (value instanceof Address) return value.publicKey;
+		if (value instanceof Uint8Array && value.length === 32) return value;
+		throw new Error(`Cannot encode value as address: ${value}`);
+	}
+	decode(bytes) {
+		return new Address(bytes).toString();
+	}
+};
+/**
+* A boolean ABI type.
+*/
+var ABIBoolType = class ABIBoolType extends ABIType {
+	get name() {
+		return "bool";
+	}
+	equals(other) {
+		return other instanceof ABIBoolType;
+	}
+	isDynamic() {
+		return false;
+	}
+	byteLen() {
+		return 1;
+	}
+	encode(value) {
+		if (typeof value !== "boolean") throw new Error(`Cannot encode value as bool: ${value}`);
+		return value ? new Uint8Array([128]) : new Uint8Array([0]);
+	}
+	decode(bytes) {
+		if (bytes.length !== 1) throw new Error(`Expected 1 byte for bool, got ${bytes.length}`);
+		return (bytes[0] & 128) !== 0;
+	}
+};
+/**
+* A single byte ABI type.
+*/
+var ABIByteType = class ABIByteType extends ABIType {
+	get name() {
+		return "byte";
+	}
+	equals(other) {
+		return other instanceof ABIByteType;
+	}
+	isDynamic() {
+		return false;
+	}
+	byteLen() {
+		return 1;
+	}
+	encode(value) {
+		if (typeof value !== "number" && typeof value !== "bigint") throw new Error(`Cannot encode value as byte: ${value}`);
+		const numberValue = typeof value === "bigint" ? Number(value) : value;
+		if (value < 0 || value > 255) throw new Error(`Byte value must be between 0 and 255, got ${numberValue}`);
+		return new Uint8Array([numberValue]);
+	}
+	decode(bytes) {
+		if (bytes.length !== 1) throw new Error(`Expected 1 byte for byte type, got ${bytes.length}`);
+		return bytes[0];
+	}
+};
+/**
+* A dynamic-length string ABI type.
+*/
+var ABIStringType = class ABIStringType extends ABIType {
+	get name() {
+		return "string";
+	}
+	equals(other) {
+		return other instanceof ABIStringType;
+	}
+	isDynamic() {
+		return true;
+	}
+	byteLen() {
+		throw new Error(`Failed to get size, string is a dynamic type`);
+	}
+	encode(value) {
+		if (typeof value !== "string" && !(value instanceof Uint8Array)) throw new Error(`Cannot encode value as string: ${value}`);
+		let encodedBytes;
+		if (typeof value === "string") encodedBytes = new TextEncoder().encode(value);
+		else encodedBytes = value;
+		const encodedLength = bigIntToBytes(encodedBytes.length, LENGTH_ENCODE_BYTE_SIZE);
+		const mergedBytes = new Uint8Array(encodedBytes.length + LENGTH_ENCODE_BYTE_SIZE);
+		mergedBytes.set(encodedLength);
+		mergedBytes.set(encodedBytes, LENGTH_ENCODE_BYTE_SIZE);
+		return mergedBytes;
+	}
+	decode(bytes) {
+		if (bytes.length < LENGTH_ENCODE_BYTE_SIZE) throw new Error(`Byte string is too short to be decoded. Actual length is ${bytes.length}, but expected at least ${LENGTH_ENCODE_BYTE_SIZE}`);
+		const byteLength = new DataView(bytes.buffer, bytes.byteOffset, LENGTH_ENCODE_BYTE_SIZE).getUint16(0);
+		const byteValue = bytes.slice(LENGTH_ENCODE_BYTE_SIZE, bytes.length);
+		if (byteLength !== byteValue.length) throw new Error(`String length bytes do not match the actual length of string. Expected ${byteLength}, got ${byteValue.length}`);
+		return new TextDecoder("utf-8").decode(byteValue);
+	}
+};
+/**
+* A tuple ABI type containing other ABI types.
+*/
+var ABITupleType = class ABITupleType extends ABIType {
+	/**
+	* Creates a new tuple type.
+	* @param childTypes The types of the tuple elements
+	*/
+	constructor(childTypes) {
+		super();
+		this.childTypes = childTypes;
+		if (childTypes.length > MAX_LEN) throw new Error(`Tuple has too many child types: ${childTypes.length}`);
+	}
+	get name() {
+		const typeStrings = [];
+		for (let i = 0; i < this.childTypes.length; i++) typeStrings[i] = this.childTypes[i].name;
+		return `(${typeStrings.join(",")})`;
+	}
+	equals(other) {
+		if (!(other instanceof ABITupleType)) return false;
+		if (this.childTypes.length !== other.childTypes.length) return false;
+		return this.childTypes.every((t, i) => t.equals(other.childTypes[i]));
+	}
+	isDynamic() {
+		return this.childTypes.some((c) => c.isDynamic());
+	}
+	byteLen() {
+		let size = 0;
+		let i = 0;
+		while (i < this.childTypes.length) {
+			const childType = this.childTypes[i];
+			if (childType instanceof ABIBoolType) {
+				const sequenceEndIndex = findBoolSequenceEnd(this.childTypes, i);
+				const boolCount = sequenceEndIndex - i + 1;
+				size += Math.ceil(boolCount / 8);
+				i = sequenceEndIndex + 1;
+			} else {
+				size += childType.byteLen();
+				i++;
+			}
+		}
+		return size;
+	}
+	encode(value) {
+		if (!Array.isArray(value) && !(value instanceof Uint8Array)) throw new Error(`Cannot encode value as ${this.toString()}: ${value}`);
+		const values = Array.from(value);
+		if (this.childTypes.length !== values.length) throw new Error("Mismatch lengths between the values and types");
+		const heads = [];
+		const tails = [];
+		const isDynamicIndex = /* @__PURE__ */ new Map();
+		let abiTypesCursor = 0;
+		while (abiTypesCursor < this.childTypes.length) {
+			const childType = this.childTypes[abiTypesCursor];
+			if (childType.isDynamic()) {
+				isDynamicIndex.set(heads.length, true);
+				heads.push(new Uint8Array(2));
+				tails.push(childType.encode(values[abiTypesCursor]));
+			} else {
+				if (childType instanceof ABIBoolType) {
+					const boolSequenceEndIndex = findBoolSequenceEnd(this.childTypes, abiTypesCursor);
+					const compressedBool = compressBools(values.slice(abiTypesCursor, boolSequenceEndIndex + 1));
+					heads.push(new Uint8Array([compressedBool]));
+					abiTypesCursor = boolSequenceEndIndex;
+				} else heads.push(childType.encode(values[abiTypesCursor]));
+				isDynamicIndex.set(abiTypesCursor, false);
+				tails.push(new Uint8Array(0));
+			}
+			abiTypesCursor += 1;
+		}
+		const headLength = heads.reduce((sum, head) => sum + head.length, 0);
+		let tailLength = 0;
+		for (let i = 0; i < heads.length; i++) {
+			if (isDynamicIndex.get(i)) {
+				const headValue = headLength + tailLength;
+				if (headValue > 65535) throw new Error(`Value ${headValue} cannot fit in u16`);
+				heads[i] = new Uint8Array([headValue >> 8 & 255, headValue & 255]);
+			}
+			tailLength += tails[i].length;
+		}
+		const totalLength = heads.reduce((sum, head) => sum + head.length, 0) + tails.reduce((sum, tail) => sum + tail.length, 0);
+		const result = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const head of heads) {
+			result.set(head, offset);
+			offset += head.length;
+		}
+		for (const tail of tails) {
+			result.set(tail, offset);
+			offset += tail.length;
+		}
+		return result;
+	}
+	decode(bytes) {
+		const valuePartitions = extractValues(this.childTypes, bytes);
+		const values = [];
+		for (let i = 0; i < this.childTypes.length; i++) {
+			const childType = this.childTypes[i];
+			const valuePartition = valuePartitions[i];
+			const childValue = childType.decode(valuePartition);
+			values.push(childValue);
+		}
+		return values;
+	}
+};
+/**
+* A static-length array ABI type.
+*/
+var ABIArrayStaticType = class ABIArrayStaticType extends ABIType {
+	/**
+	* Creates a new static array type.
+	* @param childType The type of the array elements
+	* @param length The fixed length of the array
+	*/
+	constructor(childType, length) {
+		super();
+		this.childType = childType;
+		this.length = length;
+		if (length < 0 || length > MAX_LEN) throw new Error(`Invalid static array length: ${length}`);
+	}
+	get name() {
+		return `${this.childType.name}[${this.length}]`;
+	}
+	equals(other) {
+		return other instanceof ABIArrayStaticType && this.childType.equals(other.childType) && this.length === other.length;
+	}
+	isDynamic() {
+		return this.childType.isDynamic();
+	}
+	byteLen() {
+		if (this.childType instanceof ABIBoolType) return Math.ceil(this.length / 8);
+		return this.childType.byteLen() * this.length;
+	}
+	/**
+	* Converts this static array type to an equivalent tuple type.
+	* @returns The equivalent tuple type
+	*/
+	toABITupleType() {
+		return new ABITupleType(Array(this.length).fill(this.childType));
+	}
+	encode(value) {
+		if (!Array.isArray(value) && !(value instanceof Uint8Array)) throw new Error(`Cannot encode value as ${this.name}: ${value}`);
+		if (value.length !== this.length) throw new Error(`Value array does not match static array length. Expected ${this.length}, got ${value.length}`);
+		return this.toABITupleType().encode(value);
+	}
+	decode(bytes) {
+		const decoded = this.toABITupleType().decode(bytes);
+		if (this.childType instanceof ABIByteType && Array.isArray(decoded)) return new Uint8Array(decoded);
+		return decoded;
+	}
+};
+/**
+* A dynamic-length array ABI type.
+*/
+var ABIArrayDynamicType = class ABIArrayDynamicType extends ABIType {
+	/**
+	* Creates a new dynamic array type.
+	* @param childType The type of the array elements
+	*/
+	constructor(childType) {
+		super();
+		this.childType = childType;
+	}
+	get name() {
+		return `${this.childType.name}[]`;
+	}
+	equals(other) {
+		return other instanceof ABIArrayDynamicType && this.childType.equals(other.childType);
+	}
+	isDynamic() {
+		return true;
+	}
+	byteLen() {
+		throw new Error(`Failed to get size, dynamic array is a dynamic type`);
+	}
+	/**
+	* Converts this dynamic array type to an equivalent tuple type of a given length.
+	* @param length The number of elements
+	* @returns The equivalent tuple type
+	*/
+	toABITupleType(length) {
+		return new ABITupleType(Array(length).fill(this.childType));
+	}
+	encode(value) {
+		if (!Array.isArray(value) && !(value instanceof Uint8Array)) throw new Error(`Cannot encode value as ${this.name}: ${value}`);
+		const convertedTuple = this.toABITupleType(value.length);
+		const encodedTuple = convertedTuple.encode(value);
+		return concatArrays(bigIntToBytes(convertedTuple.childTypes.length, LENGTH_ENCODE_BYTE_SIZE), encodedTuple);
+	}
+	decode(bytes) {
+		const byteLength = new DataView(bytes.buffer, 0, LENGTH_ENCODE_BYTE_SIZE).getUint16(0);
+		const decoded = this.toABITupleType(byteLength).decode(bytes.slice(LENGTH_ENCODE_BYTE_SIZE, bytes.length));
+		if (this.childType instanceof ABIByteType && Array.isArray(decoded)) return new Uint8Array(decoded);
+		return decoded;
+	}
+};
+/**
+* A struct ABI type with named fields.
+*/
+var ABIStructType = class ABIStructType extends ABIType {
+	/**
+	* Creates a new struct type.
+	* @param structName The name of the struct
+	* @param structFields The fields of the struct
+	*/
+	constructor(structName, structFields) {
+		super();
+		this.structName = structName;
+		this.structFields = structFields;
+	}
+	get name() {
+		return this.toABITupleType().name;
+	}
+	get displayName() {
+		return this.structName;
+	}
+	equals(other) {
+		if (!(other instanceof ABIStructType)) return false;
+		if (this.structName !== other.structName) return false;
+		if (this.structFields.length !== other.structFields.length) return false;
+		return this.structFields.every((f, i) => {
+			const otherField = other.structFields[i];
+			if (f.name !== otherField.name) return false;
+			if (Array.isArray(f.type) && Array.isArray(otherField.type)) return JSON.stringify(f.type) === JSON.stringify(otherField.type);
+			if (f.type instanceof ABIType && otherField.type instanceof ABIType) return f.type.equals(otherField.type);
+			return false;
+		});
+	}
+	isDynamic() {
+		return this.toABITupleType().isDynamic();
+	}
+	byteLen() {
+		return this.toABITupleType().byteLen();
+	}
+	/**
+	* Converts this struct type to an equivalent tuple type.
+	* @returns The equivalent tuple type
+	*/
+	toABITupleType() {
+		const getABITupleTypeFromABIStructFields = (fields) => {
+			return new ABITupleType(fields.map((field) => Array.isArray(field.type) ? getABITupleTypeFromABIStructFields(field.type) : field.type instanceof ABIStructType ? field.type.toABITupleType() : field.type));
+		};
+		return getABITupleTypeFromABIStructFields(this.structFields);
+	}
+	/**
+	* Creates an ABIStructType from struct name and struct definitions.
+	* @param structName The name of the struct
+	* @param structs A record of struct definitions
+	* @returns The struct type
+	*/
+	static fromStruct(structName, structs) {
+		const getStructFieldType = (structFieldType) => {
+			if (Array.isArray(structFieldType)) return structFieldType.map((structField) => ({
+				name: structField.name,
+				type: getStructFieldType(structField.type)
+			}));
+			if (structs[structFieldType]) return ABIStructType.fromStruct(structFieldType, structs);
+			return ABIType.from(structFieldType);
+		};
+		if (!structs[structName]) throw new Error("Struct not found");
+		const fields = structs[structName];
+		return new ABIStructType(structName, fields.map((f) => ({
+			name: f.name,
+			type: getStructFieldType(f.type)
+		})));
+	}
+	encode(value) {
+		if (typeof value !== "object" || Array.isArray(value) || value instanceof Uint8Array || value instanceof Address) throw new Error(`Cannot encode value as ${this.name}: ${value}`);
+		const tupleType = this.toABITupleType();
+		const tupleValue = this.getTupleValueFromStructValue(value);
+		return tupleType.encode(tupleValue);
+	}
+	decode(bytes) {
+		const tupleValue = this.toABITupleType().decode(bytes);
+		return this.getStructValueFromTupleValue(tupleValue);
+	}
+	getTupleValueFromStructValue(structValue) {
+		const getTupleValueFromStructFields = (structFields, values) => {
+			return structFields.map(({ type }, index) => {
+				if (Array.isArray(type)) {
+					const value = values[index];
+					return getTupleValueFromStructFields(type, Object.values(value));
+				}
+				if (type instanceof ABIStructType) {
+					const value = values[index];
+					return getTupleValueFromStructFields(type.structFields, Object.values(value));
+				}
+				return values[index];
+			});
+		};
+		return getTupleValueFromStructFields(this.structFields, Object.values(structValue));
+	}
+	getStructValueFromTupleValue(tupleValue) {
+		const getStructFieldValues = (structFields, values) => {
+			return Object.fromEntries(structFields.map(({ name, type }, index) => {
+				if (Array.isArray(type)) {
+					const value = values[index];
+					return [name, getStructFieldValues(type, value)];
+				}
+				if (type instanceof ABIStructType) {
+					const value = values[index];
+					return [name, getStructFieldValues(type.structFields, value)];
+				}
+				return [name, values[index]];
+			}));
+		};
+		return getStructFieldValues(this.structFields, tupleValue);
+	}
+};
+function compressBools(values) {
+	if (values.length > 8) throw new Error(`Expected no more than 8 bool values, received ${values.length}`);
+	let result = 0;
+	for (let i = 0; i < values.length; i++) {
+		if (typeof values[i] !== "boolean") throw new Error("Expected all values to be boolean");
+		if (values[i]) result |= 1 << 7 - i;
+	}
+	return result;
+}
+function findBoolSequenceEnd(abiTypes, currentIndex) {
+	let cursor = currentIndex;
+	while (cursor < abiTypes.length) if (abiTypes[cursor] instanceof ABIBoolType) {
+		if (cursor - currentIndex + 1 === 8 || cursor === abiTypes.length - 1) return cursor;
+		cursor++;
+	} else return cursor - 1;
+	return cursor - 1;
+}
+function extractValues(abiTypes, bytes) {
+	const dynamicSegments = [];
+	const valuePartitions = [];
+	let bytesCursor = 0;
+	let abiTypesCursor = 0;
+	while (abiTypesCursor < abiTypes.length) {
+		const childType = abiTypes[abiTypesCursor];
+		if (childType.isDynamic()) {
+			if (bytes.length - bytesCursor < LENGTH_ENCODE_BYTE_SIZE) throw new Error("Byte array is too short to be decoded");
+			const dynamicIndex = bytes[bytesCursor] << 8 | bytes[bytesCursor + 1];
+			if (dynamicSegments.length > 0) {
+				const lastSegment = dynamicSegments[dynamicSegments.length - 1];
+				if (dynamicIndex < lastSegment.left) throw new Error("Dynamic index segment miscalculation: left is greater than right index");
+				lastSegment.right = dynamicIndex;
+			}
+			dynamicSegments.push({
+				left: dynamicIndex,
+				right: 0
+			});
+			valuePartitions.push(null);
+			bytesCursor += LENGTH_ENCODE_BYTE_SIZE;
+		} else if (childType instanceof ABIBoolType) {
+			const boolSequenceEndIndex = findBoolSequenceEnd(abiTypes, abiTypesCursor);
+			for (let j = 0; j <= boolSequenceEndIndex - abiTypesCursor; j++) {
+				const boolMask = BOOL_TRUE_BYTE >> j;
+				if ((bytes[bytesCursor] & boolMask) > 0) valuePartitions.push(new Uint8Array([BOOL_TRUE_BYTE]));
+				else valuePartitions.push(new Uint8Array([BOOL_FALSE_BYTE]));
+			}
+			abiTypesCursor = boolSequenceEndIndex;
+			bytesCursor += 1;
+		} else {
+			const childTypeSize = childType.byteLen();
+			if (bytesCursor + childTypeSize > bytes.length) throw new Error(`Index out of bounds, trying to access bytes[${bytesCursor}..${bytesCursor + childTypeSize}] but slice has length ${bytes.length}`);
+			valuePartitions.push(bytes.slice(bytesCursor, bytesCursor + childTypeSize));
+			bytesCursor += childTypeSize;
+		}
+		if (abiTypesCursor !== abiTypes.length - 1 && bytesCursor >= bytes.length) throw new Error("Input bytes not enough to decode");
+		abiTypesCursor += 1;
+	}
+	if (dynamicSegments.length > 0) {
+		const lastSegment = dynamicSegments[dynamicSegments.length - 1];
+		lastSegment.right = bytes.length;
+	} else if (bytesCursor < bytes.length) throw new Error("Input bytes not fully consumed");
+	for (let i = 0; i < dynamicSegments.length; i++) {
+		const segment = dynamicSegments[i];
+		if (segment.left > segment.right) throw new Error("Dynamic segment should display a [l, r] space with l <= r");
+		if (i !== dynamicSegments.length - 1 && segment.right !== dynamicSegments[i + 1].left) throw new Error("Dynamic segments should be consecutive");
+	}
+	let segmentIndex = 0;
+	for (let i = 0; i < abiTypes.length; i++) if (abiTypes[i].isDynamic()) {
+		valuePartitions[i] = bytes.slice(dynamicSegments[segmentIndex].left, dynamicSegments[segmentIndex].right);
+		segmentIndex += 1;
+	}
+	const result = [];
+	for (let i = 0; i < valuePartitions.length; i++) {
+		const partition = valuePartitions[i];
+		if (partition === null) throw new Error(`Value partition at index ${i} is None`);
+		result.push(partition);
+	}
+	return result;
+}
+function parseTupleContent(content) {
+	if (content === "") return [];
+	if (content.startsWith(",")) throw new Error("The content should not start with comma");
+	if (content.endsWith(",")) throw new Error("The content should not end with comma");
+	if (content.includes(",,")) throw new Error("The content should not have consecutive commas");
+	const tupleStrings = [];
+	let depth = 0;
+	let word = "";
+	for (const ch of content) {
+		word += ch;
+		if (ch === "(") depth += 1;
+		else if (ch === ")") depth -= 1;
+		else if (ch === "," && depth === 0) {
+			word = word.slice(0, -1);
+			tupleStrings.push(word);
+			word = "";
+		}
+	}
+	if (word !== "") tupleStrings.push(word);
+	if (depth !== 0) throw new Error("The content has mismatched parentheses");
+	return tupleStrings;
+}
+
+//#endregion
+export { ABIAddressType, ABIArrayDynamicType, ABIArrayStaticType, ABIBoolType, ABIByteType, ABIStringType, ABIStructType, ABITupleType, ABIType, ABIUfixedType, ABIUintType, parseTupleContent };
+//# sourceMappingURL=abi-type.mjs.map