@beclab/olaresid 0.1.13 → 0.2.0

package/tests/unit/tag-type-parser.test.ts

@@ -0,0 +1,802 @@
+import { AbiCoder } from 'ethers';
+import { TagTypeParser } from '../../src/utils/tag-type-parser';
+import { TagTypeBuilder } from '../../src/utils/tag-type-builder';
+import { RawTagData } from '../../src/domain/types';
+
+/**
+ * Unit tests for TagTypeParser
+ * Tests tag parsing, tuple conversion, and BigInt handling
+ */
+
+describe('TagTypeParser', () => {
+	let abiCoder: AbiCoder;
+
+	beforeEach(() => {
+		abiCoder = new AbiCoder();
+	});
+
+	// ========================================
+	// Parse Tag - Basic Types
+	// ========================================
+
+	describe('parseTag - Basic Types', () => {
+		it('should parse string tag', () => {
+			const rawTag: RawTagData = {
+				from: 'global',
+				name: 'latestDID',
+				abiType: '0x03',
+				value: abiCoder.encode(['string'], ['did:key:z6Mk...']),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.name).toBe('latestDID');
+			expect(tag.abiType).toBe('string');
+			expect(tag.valueFormatted).toBe('did:key:z6Mk...');
+		});
+
+		it('should parse uint8 tag', () => {
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'age',
+				abiType: '0x0101',
+				value: abiCoder.encode(['uint8'], [30]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('uint8');
+			expect(tag.valueFormatted).toBe('30');
+		});
+
+		it('should parse uint256 tag and convert BigInt to string', () => {
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'balance',
+				abiType: '0x0120',
+				value: abiCoder.encode(['uint256'], [1000000000000000000n]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('uint256');
+			expect(tag.valueFormatted).toBe('1000000000000000000');
+			expect(typeof tag.valueFormatted).toBe('string');
+		});
+
+		it('should parse bool tag', () => {
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'verified',
+				abiType: '0x02',
+				value: abiCoder.encode(['bool'], [true]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('bool');
+			expect(tag.valueFormatted).toBe(true);
+		});
+
+		it('should parse address tag', () => {
+			const rawTag: RawTagData = {
+				from: 'global',
+				name: 'owner',
+				abiType: '0x07',
+				value: abiCoder.encode(
+					['address'],
+					['0x742d35cc6634c0532925a3b844bc9e7595f0beb0']
+				),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('address');
+			expect((tag.valueFormatted as string).toLowerCase()).toBe(
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0'
+			);
+		});
+
+		it('should parse bytes4 tag', () => {
+			const rawTag: RawTagData = {
+				from: 'global',
+				name: 'dnsARecord',
+				abiType: '0x0804',
+				value: abiCoder.encode(['bytes4'], ['0xc0a80101']),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('bytes4');
+			expect(tag.valueFormatted).toBe('0xc0a80101');
+		});
+	});
+
+	// ========================================
+	// Parse Tag - Array Types
+	// ========================================
+
+	describe('parseTag - Array Types', () => {
+		it('should parse address array', () => {
+			const addresses = [
+				'0x1111111111111111111111111111111111111111',
+				'0x2222222222222222222222222222222222222222'
+			];
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'wallets',
+				abiType: '0x0407',
+				value: abiCoder.encode(['address[]'], [addresses]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('address[]');
+			const parsedAddresses = JSON.parse(tag.valueFormatted as string);
+			expect(Array.isArray(parsedAddresses)).toBe(true);
+			expect(parsedAddresses.length).toBe(2);
+		});
+
+		it('should parse string array', () => {
+			const links = ['https://x.com/alice', 'https://github.com/alice'];
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'socialLinks',
+				abiType: '0x0403',
+				value: abiCoder.encode(['string[]'], [links]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('string[]');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual(links);
+		});
+
+		it('should parse uint256 array and convert BigInt to string', () => {
+			const numbers = [100n, 200n, 300n];
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'scores',
+				abiType: '0x040120',
+				value: abiCoder.encode(['uint256[]'], [numbers]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('uint256[]');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual([
+				'100',
+				'200',
+				'300'
+			]);
+		});
+	});
+
+	// ========================================
+	// Parse Tag - Simple Tuple
+	// ========================================
+
+	describe('parseTag - Simple Tuple', () => {
+		it('should parse simple tuple with field names', () => {
+			const value = ['Alice', 30];
+			const hash =
+				'0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'userInfo',
+				abiType: '0x060002030101',
+				value: abiCoder.encode(['tuple(string,uint8)'], [value]),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, ['name', 'age']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(string,uint8)');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual({
+				name: 'Alice',
+				age: '30'
+			});
+		});
+
+		it('should parse tuple without field names (return array)', () => {
+			const value = ['Alice', 30];
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'userInfo',
+				abiType: '0x060002030101',
+				value: abiCoder.encode(['tuple(string,uint8)'], [value]),
+				fieldNamesHash: []
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(string,uint8)');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual([
+				'Alice',
+				'30'
+			]);
+		});
+
+		it('should parse tuple with complex types', () => {
+			const value = [
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0',
+				1000n,
+				true
+			];
+			const hash =
+				'0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'profile',
+				abiType: '0x060003070120020',
+				value: abiCoder.encode(
+					['tuple(address,uint256,bool)'],
+					[value]
+				),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, ['owner', 'balance', 'active']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(address,uint256,bool)');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual({
+				owner: expect.any(String),
+				balance: '1000',
+				active: true
+			});
+		});
+	});
+
+	// ========================================
+	// Parse Tag - Nested Tuple
+	// ========================================
+
+	describe('parseTag - Nested Tuple', () => {
+		it('should parse nested tuple with field names', () => {
+			const value = ['Bob', [25, true]];
+			const hash1 =
+				'0x1111111111111111111111111111111111111111111111111111111111111111';
+			const hash2 =
+				'0x2222222222222222222222222222222222222222222222222222222222222222';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'profile',
+				abiType: '0x06000203060002010102',
+				value: abiCoder.encode(
+					['tuple(string,tuple(uint8,bool))'],
+					[value]
+				),
+				fieldNamesHash: [hash1, hash2]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash1, ['name', 'details']);
+			fieldNamesMap.set(hash2, ['age', 'verified']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(string,tuple(uint8,bool))');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual({
+				name: 'Bob',
+				details: {
+					age: '25',
+					verified: true
+				}
+			});
+		});
+
+		it('should parse deeply nested tuple', () => {
+			const value = ['Alice', [30, ['alice@example.com', '+1-555-0123']]];
+			const hash1 =
+				'0xaaaa111111111111111111111111111111111111111111111111111111111111';
+			const hash2 =
+				'0xbbbb222222222222222222222222222222222222222222222222222222222222';
+			const hash3 =
+				'0xcccc333333333333333333333333333333333333333333333333333333333333';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'profile',
+				abiType: '0x06000203060002010106000203030',
+				value: abiCoder.encode(
+					['tuple(string,tuple(uint8,tuple(string,string)))'],
+					[value]
+				),
+				fieldNamesHash: [hash1, hash2, hash3]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash1, ['name', 'details']);
+			fieldNamesMap.set(hash2, ['age', 'contact']);
+			fieldNamesMap.set(hash3, ['email', 'phone']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe(
+				'tuple(string,tuple(uint8,tuple(string,string)))'
+			);
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual({
+				name: 'Alice',
+				details: {
+					age: '30',
+					contact: {
+						email: 'alice@example.com',
+						phone: '+1-555-0123'
+					}
+				}
+			});
+		});
+	});
+
+	// ========================================
+	// Parse Tag - Tuple Array
+	// ========================================
+
+	describe('parseTag - Tuple Array', () => {
+		it('should parse simple tuple array', () => {
+			const value = [
+				[0, '0x742d35cc6634c0532925a3b844bc9e7595f0beb0'],
+				[1, '0x1111111111111111111111111111111111111111']
+			];
+			const hash =
+				'0xa7011a7789e2d5350dd5d7f1cd1b05f9c6948c18fcad68f64983c8488b9b5625';
+
+			const rawTag: RawTagData = {
+				from: '',
+				name: 'authAddresses',
+				abiType: '0x04060002010107',
+				value: abiCoder.encode(['tuple(uint8,address)[]'], [value]),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, ['algorithm', 'addr']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(uint8,address)[]');
+			const parsedAuthAddr = JSON.parse(tag.valueFormatted as string);
+			expect(Array.isArray(parsedAuthAddr)).toBe(true);
+			expect(parsedAuthAddr).toEqual([
+				{ algorithm: '0', addr: expect.any(String) },
+				{ algorithm: '1', addr: expect.any(String) }
+			]);
+		});
+
+		it('should parse nested tuple array', () => {
+			const value = [
+				[1, ['Alice', true]],
+				[2, ['Bob', false]]
+			];
+			const hash1 =
+				'0x1111111111111111111111111111111111111111111111111111111111111111';
+			const hash2 =
+				'0x2222222222222222222222222222222222222222222222222222222222222222';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'items',
+				abiType: '0x04060002012006000203020',
+				value: abiCoder.encode(
+					['tuple(uint256,tuple(string,bool))[]'],
+					[value]
+				),
+				fieldNamesHash: [hash1, hash2]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash1, ['id', 'data']);
+			fieldNamesMap.set(hash2, ['name', 'active']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(uint256,tuple(string,bool))[]');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual([
+				{ id: '1', data: { name: 'Alice', active: true } },
+				{ id: '2', data: { name: 'Bob', active: false } }
+			]);
+		});
+
+		it('should parse empty tuple array', () => {
+			const value: any[] = [];
+			const hash =
+				'0xa7011a7789e2d5350dd5d7f1cd1b05f9c6948c18fcad68f64983c8488b9b5625';
+
+			const rawTag: RawTagData = {
+				from: '',
+				name: 'authAddresses',
+				abiType: '0x04060002010107',
+				value: abiCoder.encode(['tuple(uint8,address)[]'], [value]),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, ['algorithm', 'addr']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(uint8,address)[]');
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual([]);
+		});
+	});
+
+	// ========================================
+	// Parse Tag - Complex Nested Tuples
+	// ========================================
+
+	describe('parseTag - Complex Nested Tuples', () => {
+		it('should parse tuple with multiple nested tuples', () => {
+			const value = [
+				'Alice Johnson',
+				[30, true],
+				['alice@example.com', '+1-555-0123']
+			];
+			const hash1 =
+				'0xbd67eb3ac6cf9025dadacf21cbc2fc2db499fc6154f0f8ff2ff87e114d60ad27';
+			const hash2 =
+				'0x2f85d0ec24ccc16f8739d2e76938c4e5104a4438ce0d6d2f9a793527d77aaf20';
+			const hash3 =
+				'0xc414cfe30fe6ad154c340fa4048fd9d2e36e551d4860498cb63f84188b08ffa4';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'profile',
+				abiType: '0x06000303060002010102060002030303',
+				value: abiCoder.encode(
+					['tuple(string,tuple(uint8,bool),tuple(string,string))'],
+					[value]
+				),
+				fieldNamesHash: [hash1, hash2, hash3]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash1, ['name', 'details', 'contact']);
+			fieldNamesMap.set(hash2, ['age', 'verified']);
+			fieldNamesMap.set(hash3, ['email', 'phone']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe(
+				'tuple(string,tuple(uint8,bool),tuple(string,string))'
+			);
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual({
+				name: 'Alice Johnson',
+				details: {
+					age: '30',
+					verified: true
+				},
+				contact: {
+					email: 'alice@example.com',
+					phone: '+1-555-0123'
+				}
+			});
+		});
+
+		it('should parse tuple with array field', () => {
+			const value = [
+				'Alice',
+				31,
+				[
+					'0x1111111111111111111111111111111111111111',
+					'0x2222222222222222222222222222222222222222'
+				],
+				true
+			];
+			const hash =
+				'0xf1e429c1ee11d289bde872dd17c5937a9da2ad9212b711c15ff5afe8828ebcba';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'userInfo',
+				abiType: '0x0600040301010407020',
+				value: abiCoder.encode(
+					['tuple(string,uint8,address[],bool)'],
+					[value]
+				),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, ['name', 'age', 'wallets', 'verified']);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe('tuple(string,uint8,address[],bool)');
+			const parsedTuple = JSON.parse(tag.valueFormatted as string);
+			expect(parsedTuple).toEqual({
+				name: 'Alice',
+				age: '31',
+				wallets: expect.any(Array),
+				verified: true
+			});
+			expect(parsedTuple.wallets.length).toBe(2);
+		});
+	});
+
+	// ========================================
+	// convertTupleToObject - Direct Tests
+	// ========================================
+
+	describe('convertTupleToObject', () => {
+		it('should convert simple tuple array to object', () => {
+			const value = ['Alice', 30];
+			const allFieldNames = [['name', 'age']];
+			const context = { fieldNameIndex: 0 };
+
+			const result = TagTypeParser.convertTupleToObject(
+				value,
+				'tuple(string,uint8)',
+				allFieldNames,
+				context
+			);
+
+			expect(result).toEqual({ name: 'Alice', age: 30 });
+			expect(context.fieldNameIndex).toBe(1);
+		});
+
+		it('should convert nested tuple to object', () => {
+			const value = ['Bob', [25, true]];
+			const allFieldNames = [
+				['name', 'profile'],
+				['age', 'verified']
+			];
+			const context = { fieldNameIndex: 0 };
+
+			const result = TagTypeParser.convertTupleToObject(
+				value,
+				'tuple(string,tuple(uint8,bool))',
+				allFieldNames,
+				context
+			);
+
+			expect(result).toEqual({
+				name: 'Bob',
+				profile: { age: 25, verified: true }
+			});
+			expect(context.fieldNameIndex).toBe(2);
+		});
+
+		it('should handle field name/value length mismatch', () => {
+			const value = ['Alice', 30, 'extra'];
+			const allFieldNames = [['name', 'age']]; // Only 2 field names
+			const context = { fieldNameIndex: 0 };
+
+			const result = TagTypeParser.convertTupleToObject(
+				value,
+				'tuple(string,uint8)',
+				allFieldNames,
+				context
+			);
+
+			// Should return original value when mismatch
+			expect(result).toEqual(value);
+		});
+
+		it('should handle missing field names', () => {
+			const value = ['Alice', 30];
+			const allFieldNames: string[][] = []; // No field names
+			const context = { fieldNameIndex: 0 };
+
+			const result = TagTypeParser.convertTupleToObject(
+				value,
+				'tuple(string,uint8)',
+				allFieldNames,
+				context
+			);
+
+			// Should return original value when no field names
+			expect(result).toEqual(value);
+		});
+
+		it('should return non-array values as-is', () => {
+			const value = 'not-an-array';
+			const allFieldNames = [['name', 'age']];
+			const context = { fieldNameIndex: 0 };
+
+			const result = TagTypeParser.convertTupleToObject(
+				value,
+				'tuple(string,uint8)',
+				allFieldNames,
+				context
+			);
+
+			expect(result).toBe(value);
+		});
+	});
+
+	// ========================================
+	// convertBigIntToString - Direct Tests
+	// ========================================
+
+	describe('convertBigIntToString', () => {
+		it('should convert BigInt to string', () => {
+			const result = TagTypeParser.convertBigIntToString(1000n);
+			expect(result).toBe('1000');
+			expect(typeof result).toBe('string');
+		});
+
+		it('should convert BigInt in array', () => {
+			const result = TagTypeParser.convertBigIntToString([
+				100n,
+				200n,
+				300n
+			]);
+			expect(result).toEqual(['100', '200', '300']);
+		});
+
+		it('should convert BigInt in object', () => {
+			const result = TagTypeParser.convertBigIntToString({
+				balance: 1000n,
+				amount: 2000n
+			});
+			expect(result).toEqual({
+				balance: '1000',
+				amount: '2000'
+			});
+		});
+
+		it('should handle nested structures with BigInt', () => {
+			const result = TagTypeParser.convertBigIntToString({
+				user: {
+					balances: [100n, 200n],
+					total: 300n
+				},
+				active: true
+			});
+			expect(result).toEqual({
+				user: {
+					balances: ['100', '200'],
+					total: '300'
+				},
+				active: true
+			});
+		});
+
+		it('should handle primitives and non-BigInt values', () => {
+			expect(TagTypeParser.convertBigIntToString('hello')).toBe('hello');
+			expect(TagTypeParser.convertBigIntToString(123)).toBe(123);
+			expect(TagTypeParser.convertBigIntToString(true)).toBe(true);
+			expect(TagTypeParser.convertBigIntToString(null)).toBe(null);
+		});
+	});
+
+	// ========================================
+	// Edge Cases
+	// ========================================
+
+	describe('Edge Cases', () => {
+		it('should handle tuple with all primitive types', () => {
+			const value = [
+				'test',
+				123,
+				true,
+				'0x742d35cc6634c0532925a3b844bc9e7595f0beb0',
+				'0xabcdef',
+				100n
+			];
+			const hash =
+				'0xedge111111111111111111111111111111111111111111111111111111111111';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'mixed',
+				abiType: '0x0600060301010207090120',
+				value: abiCoder.encode(
+					['tuple(string,uint8,bool,address,bytes,uint256)'],
+					[value]
+				),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			fieldNamesMap.set(hash, [
+				'str',
+				'num',
+				'flag',
+				'addr',
+				'data',
+				'balance'
+			]);
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(tag.abiType).toBe(
+				'tuple(string,uint8,bool,address,bytes,uint256)'
+			);
+			const parsedMixed = JSON.parse(tag.valueFormatted as string);
+			expect(parsedMixed.str).toBe('test');
+			expect(parsedMixed.num).toBe('123');
+			expect(parsedMixed.flag).toBe(true);
+			expect(parsedMixed.balance).toBe('100');
+		});
+
+		it('should warn when field names not found for tuple', () => {
+			const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+			const value = ['Alice', 30];
+			const hash =
+				'0xnonexistent1111111111111111111111111111111111111111111111111111';
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'userInfo',
+				abiType: '0x060002030101',
+				value: abiCoder.encode(['tuple(string,uint8)'], [value]),
+				fieldNamesHash: [hash]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			// Not adding the hash to fieldNamesMap
+
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			// Should have been called with the warning message
+			expect(warnSpy).toHaveBeenCalledTimes(1);
+			const callArgs = warnSpy.mock.calls[0];
+			expect(callArgs[0]).toContain('Field names not found');
+			expect(callArgs[0]).toContain('userInfo');
+
+			expect(JSON.parse(tag.valueFormatted as string)).toEqual([
+				'Alice',
+				'30'
+			]); // Falls back to array
+
+			warnSpy.mockRestore();
+		});
+
+		it('should not warn for zero hash', () => {
+			const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+			const value = ['Alice', 30];
+
+			const rawTag: RawTagData = {
+				from: '1.com',
+				name: 'userInfo',
+				abiType: '0x060002030101',
+				value: abiCoder.encode(['tuple(string,uint8)'], [value]),
+				fieldNamesHash: [
+					'0x0000000000000000000000000000000000000000000000000000000000000000'
+				]
+			};
+
+			const fieldNamesMap = new Map<string, string[]>();
+			const tag = TagTypeParser.parseTag(rawTag, fieldNamesMap, abiCoder);
+
+			expect(warnSpy).toHaveBeenCalledTimes(0);
+
+			warnSpy.mockRestore();
+		});
+	});
+});