@beclab/olaresid 0.1.12 → 0.2.0

package/tests/unit/tag-types.test.ts

@@ -0,0 +1,821 @@
+import { AbiCoder } from 'ethers';
+import { TagTypeBuilder } from '../../src/utils/tag-type-builder';
+
+/**
+ * Comprehensive tests for Tag type encoding/decoding
+ * Covers all tag types: basic, arrays, tuples, and nested structures
+ *
+ * Run: npm run test:unit
+ */
+
+describe('Tag Type Encoding/Decoding', () => {
+	let abiCoder: AbiCoder;
+
+	beforeAll(() => {
+		abiCoder = new AbiCoder();
+	});
+
+	// ========================================
+	// Basic Types
+	// ========================================
+
+	describe('Basic Types', () => {
+		it('should handle string type', () => {
+			const builder = TagTypeBuilder.string();
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('string');
+
+			// Parse back
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('string');
+
+			// Encode/Decode
+			const value = 'Hello World';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle uint256 type', () => {
+			const builder = TagTypeBuilder.uint256();
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('uint256');
+			expect(typeBytes).toBe('0x0120');
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('uint256');
+
+			const value = 12345n;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle uint8 type', () => {
+			const builder = TagTypeBuilder.uint8();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('uint8');
+
+			const value = 255n;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle int256 type', () => {
+			const builder = TagTypeBuilder.int256();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('int256');
+
+			const value = -12345n;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle bool type', () => {
+			const builder = TagTypeBuilder.bool();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('bool');
+
+			const value = true;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle address type', () => {
+			const builder = TagTypeBuilder.address();
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('address');
+			expect(typeBytes).toBe('0x07');
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('address');
+
+			const value = '0x742d35cc6634c0532925a3b844bc9e7595f0beb0';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0].toLowerCase()).toBe(value.toLowerCase());
+		});
+
+		it('should handle bytes type', () => {
+			const builder = TagTypeBuilder.bytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('bytes');
+
+			const value = '0x1234567890abcdef';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle bytes32 type', () => {
+			const builder = TagTypeBuilder.bytes32();
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('bytes32');
+			expect(typeBytes).toBe('0x0820');
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('bytes32');
+
+			const value =
+				'0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle bytes4 type', () => {
+			const builder = TagTypeBuilder.fixedBytes(4);
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('bytes4');
+
+			const value = '0x12345678';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+	});
+
+	// ========================================
+	// Array Types
+	// ========================================
+
+	describe('Array Types', () => {
+		it('should handle string[] type', () => {
+			const builder = TagTypeBuilder.stringArray();
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('string[]');
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('string[]');
+
+			const value = ['hello', 'world', 'test'];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle uint256[] type', () => {
+			const builder = TagTypeBuilder.uint256Array();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('uint256[]');
+
+			const value = [1n, 2n, 3n, 100n];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle address[] type', () => {
+			const builder = TagTypeBuilder.addressArray();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('address[]');
+
+			const value = [
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0',
+				'0x1234567890123456789012345678901234567890'
+			];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0].map((a: string) => a.toLowerCase())).toEqual(
+				value.map((a) => a.toLowerCase())
+			);
+		});
+
+		it('should handle bool[] type', () => {
+			const builder = TagTypeBuilder.array(TagTypeBuilder.bool());
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('bool[]');
+
+			const value = [true, false, true, true];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle fixed-length array string[3]', () => {
+			const builder = TagTypeBuilder.fixedArray(
+				TagTypeBuilder.string(),
+				3
+			);
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('string[3]');
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('string[3]');
+
+			const value = ['a', 'b', 'c'];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+	});
+
+	// ========================================
+	// Tuple Types
+	// ========================================
+
+	describe('Tuple Types', () => {
+		it('should handle simple tuple(string,uint8)', () => {
+			const builder = TagTypeBuilder.tuple({
+				name: TagTypeBuilder.string(),
+				age: TagTypeBuilder.uint8()
+			});
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe('tuple(string,uint8)');
+			expect(fieldNames).toEqual([['name', 'age']]);
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('tuple(string,uint8)');
+
+			// Array format
+			const value = ['Alice', 30n];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle tuple(address,uint256,bool)', () => {
+			const builder = TagTypeBuilder.tuple({
+				owner: TagTypeBuilder.address(),
+				balance: TagTypeBuilder.uint256(),
+				active: TagTypeBuilder.bool()
+			});
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe('tuple(address,uint256,bool)');
+			expect(fieldNames).toEqual([['owner', 'balance', 'active']]);
+
+			const value = [
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0',
+				1000n,
+				true
+			];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect((decoded[0][0] as string).toLowerCase()).toBe(
+				(value[0] as string).toLocaleLowerCase()
+			);
+			expect(decoded[0][1]).toBe(value[1]);
+			expect(decoded[0][2]).toBe(value[2]);
+		});
+
+		it('should handle nested tuple(string,tuple(uint8,bool))', () => {
+			const builder = TagTypeBuilder.tuple({
+				name: TagTypeBuilder.string(),
+				profile: TagTypeBuilder.tuple({
+					age: TagTypeBuilder.uint8(),
+					verified: TagTypeBuilder.bool()
+				})
+			});
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe('tuple(string,tuple(uint8,bool))');
+			expect(fieldNames).toEqual([
+				['name', 'profile'],
+				['age', 'verified']
+			]);
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('tuple(string,tuple(uint8,bool))');
+
+			const value = ['Bob', [25n, false]];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle deeply nested tuple', () => {
+			const builder = TagTypeBuilder.tuple({
+				id: TagTypeBuilder.uint256(),
+				data: TagTypeBuilder.tuple({
+					name: TagTypeBuilder.string(),
+					meta: TagTypeBuilder.tuple({
+						created: TagTypeBuilder.uint256(),
+						active: TagTypeBuilder.bool()
+					})
+				})
+			});
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe(
+				'tuple(uint256,tuple(string,tuple(uint256,bool)))'
+			);
+			expect(fieldNames).toEqual([
+				['id', 'data'],
+				['name', 'meta'],
+				['created', 'active']
+			]);
+
+			const value = [1n, ['Test', [1234567890n, true]]];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+	});
+
+	// ========================================
+	// Array of Tuples
+	// ========================================
+
+	describe('Array of Tuples', () => {
+		it('should handle tuple(string,uint8)[] type', () => {
+			const builder = TagTypeBuilder.array(
+				TagTypeBuilder.tuple({
+					name: TagTypeBuilder.string(),
+					age: TagTypeBuilder.uint8()
+				})
+			);
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe('tuple(string,uint8)[]');
+			expect(fieldNames).toEqual([['name', 'age']]);
+
+			const parsedType =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsedType).toBe('tuple(string,uint8)[]');
+
+			const value = [
+				['Alice', 30n],
+				['Bob', 25n],
+				['Charlie', 35n]
+			];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle nested tuple array', () => {
+			const builder = TagTypeBuilder.array(
+				TagTypeBuilder.tuple({
+					id: TagTypeBuilder.uint256(),
+					data: TagTypeBuilder.tuple({
+						name: TagTypeBuilder.string(),
+						active: TagTypeBuilder.bool()
+					})
+				})
+			);
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe('tuple(uint256,tuple(string,bool))[]');
+			expect(fieldNames).toEqual([
+				['id', 'data'],
+				['name', 'active']
+			]);
+
+			const value = [
+				[1n, ['Item1', true]],
+				[2n, ['Item2', false]]
+			];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+	});
+
+	// ========================================
+	// Complex Mixed Types
+	// ========================================
+
+	describe('Complex Mixed Types', () => {
+		it('should handle tuple with array field', () => {
+			const builder = TagTypeBuilder.tuple({
+				name: TagTypeBuilder.string(),
+				tags: TagTypeBuilder.stringArray(),
+				count: TagTypeBuilder.uint256()
+			});
+			const abiType = builder.getAbiTypeString();
+
+			expect(abiType).toBe('tuple(string,string[],uint256)');
+
+			const value = ['Project', ['tag1', 'tag2', 'tag3'], 100n];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle tuple with multiple nested structures', () => {
+			const builder = TagTypeBuilder.tuple({
+				owner: TagTypeBuilder.address(),
+				metadata: TagTypeBuilder.tuple({
+					name: TagTypeBuilder.string(),
+					tags: TagTypeBuilder.stringArray()
+				}),
+				settings: TagTypeBuilder.tuple({
+					enabled: TagTypeBuilder.bool(),
+					maxValue: TagTypeBuilder.uint256()
+				})
+			});
+			const abiType = builder.getAbiTypeString();
+			const fieldNames = builder.getFieldNames();
+
+			expect(abiType).toBe(
+				'tuple(address,tuple(string,string[]),tuple(bool,uint256))'
+			);
+			expect(fieldNames.length).toBe(3);
+
+			const value = [
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0',
+				['MyProject', ['web3', 'defi']],
+				[true, 1000n]
+			];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect((decoded[0][0] as string).toLowerCase()).toBe(
+				(value[0] as string).toLowerCase()
+			);
+			expect(decoded[0][1]).toEqual(value[1]);
+			expect(decoded[0][2]).toEqual(value[2]);
+		});
+	});
+
+	// ========================================
+	// Type Bytes Parsing
+	// ========================================
+
+	describe('Type Bytes Parsing', () => {
+		it('should parse simple type bytes correctly', () => {
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x03')).toBe(
+				'string'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x0101')).toBe(
+				'uint8'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x0120')).toBe(
+				'uint256'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x02')).toBe(
+				'bool'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x07')).toBe(
+				'address'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x09')).toBe(
+				'bytes'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x0820')).toBe(
+				'bytes32'
+			);
+		});
+
+		it('should parse array type bytes correctly', () => {
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x0403')).toBe(
+				'string[]'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x0407')).toBe(
+				'address[]'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x040120')).toBe(
+				'uint256[]'
+			);
+		});
+
+		it('should parse fixed array type bytes correctly', () => {
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x05000303')).toBe(
+				'string[3]'
+			);
+			expect(TagTypeBuilder.parseTypeBytesToAbiString('0x05000507')).toBe(
+				'address[5]'
+			);
+		});
+
+		it('should parse simple tuple type bytes correctly', () => {
+			// tuple(string,uint8)
+			expect(
+				TagTypeBuilder.parseTypeBytesToAbiString('0x060002030101')
+			).toBe('tuple(string,uint8)');
+		});
+
+		it('should parse complex tuple type bytes correctly', () => {
+			// tuple(string,uint8,address[],bool) - from tag-management.ts
+			expect(
+				TagTypeBuilder.parseTypeBytesToAbiString('0x060004030101040702')
+			).toBe('tuple(string,uint8,address[],bool)');
+		});
+
+		it('should parse nested tuple type bytes correctly', () => {
+			// Build nested tuple and verify parsing
+			const builder = TagTypeBuilder.tuple({
+				name: TagTypeBuilder.string(),
+				profile: TagTypeBuilder.tuple({
+					age: TagTypeBuilder.uint8(),
+					active: TagTypeBuilder.bool()
+				})
+			});
+			const typeBytes = '0x' + builder.getTypeBytes();
+			const parsed = TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+			expect(parsed).toBe('tuple(string,tuple(uint8,bool))');
+		});
+
+		it('should roundtrip: build -> parse -> build', () => {
+			const original = TagTypeBuilder.tuple({
+				id: TagTypeBuilder.uint256(),
+				data: TagTypeBuilder.stringArray(),
+				owner: TagTypeBuilder.address()
+			});
+
+			const typeBytes = '0x' + original.getTypeBytes();
+			const parsedAbi =
+				TagTypeBuilder.parseTypeBytesToAbiString(typeBytes);
+
+			expect(parsedAbi).toBe('tuple(uint256,string[],address)');
+			expect(parsedAbi).toBe(original.getAbiTypeString());
+		});
+	});
+
+	// ========================================
+	// Object to Array Conversion
+	// ========================================
+
+	describe('Object to Array Conversion', () => {
+		it('should return non-object values as-is', () => {
+			expect(TagTypeBuilder.convertObjectToArray('string', 'hello')).toBe(
+				'hello'
+			);
+			expect(TagTypeBuilder.convertObjectToArray('uint256', 123n)).toBe(
+				123n
+			);
+			expect(TagTypeBuilder.convertObjectToArray('bool', true)).toBe(
+				true
+			);
+			expect(TagTypeBuilder.convertObjectToArray('address', null)).toBe(
+				null
+			);
+		});
+
+		it('should return arrays as-is', () => {
+			const arr = ['Alice', 30];
+			expect(
+				TagTypeBuilder.convertObjectToArray('tuple(string,uint8)', arr)
+			).toBe(arr);
+		});
+
+		it('should return non-tuple types as-is', () => {
+			const obj = { foo: 'bar' };
+			expect(TagTypeBuilder.convertObjectToArray('string', obj)).toBe(
+				obj
+			);
+		});
+
+		it('should convert simple tuple object to array', () => {
+			const obj = { name: 'Alice', age: 30 };
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(string,uint8)',
+				obj
+			);
+			expect(result).toEqual(['Alice', 30]);
+		});
+
+		it('should convert nested tuple object to array', () => {
+			const obj = {
+				name: 'Bob',
+				profile: {
+					age: 25,
+					verified: true
+				}
+			};
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(string,tuple(uint8,bool))',
+				obj
+			);
+			expect(result).toEqual(['Bob', [25, true]]);
+		});
+
+		it('should convert deeply nested tuple object to array', () => {
+			const obj = {
+				id: 1,
+				data: {
+					name: 'Test',
+					meta: {
+						created: 1234567890,
+						active: true
+					}
+				}
+			};
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(uint256,tuple(string,tuple(uint256,bool)))',
+				obj
+			);
+			expect(result).toEqual([1, ['Test', [1234567890, true]]]);
+		});
+
+		it('should handle tuple with mixed types', () => {
+			const obj = {
+				owner: '0x1234567890123456789012345678901234567890',
+				balance: 1000n,
+				active: true
+			};
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(address,uint256,bool)',
+				obj
+			);
+			expect(result).toEqual([
+				'0x1234567890123456789012345678901234567890',
+				1000n,
+				true
+			]);
+		});
+
+		it('should throw error on field count mismatch', () => {
+			const obj = { name: 'Alice' }; // Missing 'age' field
+			expect(() => {
+				TagTypeBuilder.convertObjectToArray('tuple(string,uint8)', obj);
+			}).toThrow('Tuple field count mismatch');
+		});
+
+		it('should convert tuple array (tuple[]) correctly', () => {
+			const objArray = [
+				{
+					algorithm: 0,
+					addr: '0x742d35cc6634c0532925a3b844bc9e7595f0beb0'
+				},
+				{
+					algorithm: 1,
+					addr: '0x1111111111111111111111111111111111111111'
+				}
+			];
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(uint8,address)[]',
+				objArray
+			);
+			expect(result).toEqual([
+				[0, '0x742d35cc6634c0532925a3b844bc9e7595f0beb0'],
+				[1, '0x1111111111111111111111111111111111111111']
+			]);
+		});
+
+		it('should handle nested tuple within tuple array', () => {
+			const objArray = [
+				{
+					id: 1,
+					data: {
+						name: 'Alice',
+						active: true
+					}
+				},
+				{
+					id: 2,
+					data: {
+						name: 'Bob',
+						active: false
+					}
+				}
+			];
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(uint256,tuple(string,bool))[]',
+				objArray
+			);
+			expect(result).toEqual([
+				[1, ['Alice', true]],
+				[2, ['Bob', false]]
+			]);
+		});
+
+		it('should handle empty tuple array', () => {
+			const objArray: any[] = [];
+			const result = TagTypeBuilder.convertObjectToArray(
+				'tuple(uint8,address)[]',
+				objArray
+			);
+			expect(result).toEqual([]);
+		});
+	});
+
+	// ========================================
+	// Parse Tuple Field Types
+	// ========================================
+
+	describe('Parse Tuple Field Types', () => {
+		it('should parse simple tuple fields', () => {
+			const fields = TagTypeBuilder.parseTupleFieldTypes(
+				'tuple(string,uint8)'
+			);
+			expect(fields).toEqual(['string', 'uint8']);
+		});
+
+		it('should parse tuple with multiple fields', () => {
+			const fields = TagTypeBuilder.parseTupleFieldTypes(
+				'tuple(address,uint256,bool,string)'
+			);
+			expect(fields).toEqual(['address', 'uint256', 'bool', 'string']);
+		});
+
+		it('should parse nested tuple fields', () => {
+			const fields = TagTypeBuilder.parseTupleFieldTypes(
+				'tuple(string,tuple(uint8,bool))'
+			);
+			expect(fields).toEqual(['string', 'tuple(uint8,bool)']);
+		});
+
+		it('should parse deeply nested tuple fields', () => {
+			const fields = TagTypeBuilder.parseTupleFieldTypes(
+				'tuple(uint256,tuple(string,tuple(uint256,bool)))'
+			);
+			expect(fields).toEqual([
+				'uint256',
+				'tuple(string,tuple(uint256,bool))'
+			]);
+		});
+
+		it('should parse tuple with array fields', () => {
+			const fields = TagTypeBuilder.parseTupleFieldTypes(
+				'tuple(string,string[],uint256)'
+			);
+			expect(fields).toEqual(['string', 'string[]', 'uint256']);
+		});
+
+		it('should return empty array for non-tuple types', () => {
+			expect(TagTypeBuilder.parseTupleFieldTypes('string')).toEqual([]);
+			expect(TagTypeBuilder.parseTupleFieldTypes('uint256')).toEqual([]);
+			expect(TagTypeBuilder.parseTupleFieldTypes('address[]')).toEqual(
+				[]
+			);
+		});
+	});
+
+	// ========================================
+	// Edge Cases
+	// ========================================
+
+	describe('Edge Cases', () => {
+		it('should handle empty string', () => {
+			const builder = TagTypeBuilder.string();
+			const abiType = builder.getAbiTypeString();
+
+			const value = '';
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle empty array', () => {
+			const builder = TagTypeBuilder.stringArray();
+			const abiType = builder.getAbiTypeString();
+
+			const value: string[] = [];
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toEqual(value);
+		});
+
+		it('should handle zero values', () => {
+			const builder = TagTypeBuilder.uint256();
+			const abiType = builder.getAbiTypeString();
+
+			const value = 0n;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+
+		it('should handle max uint256', () => {
+			const builder = TagTypeBuilder.uint256();
+			const abiType = builder.getAbiTypeString();
+
+			const value = 2n ** 256n - 1n;
+			const encoded = abiCoder.encode([abiType], [value]);
+			const decoded = abiCoder.decode([abiType], encoded);
+			expect(decoded[0]).toBe(value);
+		});
+	});
+});