@beclab/olaresid 0.1.1 → 0.1.2

package/examples/tag-nested-tuple.ts

@@ -0,0 +1,190 @@
+import OlaresID from '../src/index';
+import { TagTypeBuilder } from '../src/utils/tag-type-builder';
+
+// Helper function to wait for blockchain indexing
+async function waitForIndexing(seconds: number = 3) {
+	console.log(`⏳ Waiting ${seconds} seconds for blockchain indexing...`);
+	await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+}
+
+/**
+ * Example: Nested Tuple Tag Operations
+ * Demonstrates automatic object-to-array conversion for nested tuples
+ */
+
+async function main() {
+	const domainName = process.argv[2];
+	if (!domainName) {
+		console.error(
+			'Usage: npx ts-node examples/tag-nested-tuple.ts <domain-name>'
+		);
+		process.exit(1);
+	}
+
+	const privateKeyOrMnemonic = process.env.PRIVATE_KEY_OR_MNEMONIC;
+	if (!privateKeyOrMnemonic) {
+		console.error(
+			'Error: PRIVATE_KEY_OR_MNEMONIC environment variable is required'
+		);
+		process.exit(1);
+	}
+
+	console.log('🚀 Nested Tuple Tag Example\n');
+	console.log(`Domain: ${domainName}\n`);
+
+	// Initialize
+	const olaresId = OlaresID.createTestnet();
+	await olaresId.setSigner(privateKeyOrMnemonic);
+	const domain = olaresId.domain(domainName);
+	const tagCtx = domain.tag();
+	const signerAddress = await olaresId.signer!.getAddress();
+
+	// ========================================
+	// Part 1: Define Nested Tuple Type
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 1: Define Nested Tuple Type');
+	console.log('='.repeat(60));
+
+	const profileType = TagTypeBuilder.tuple({
+		name: TagTypeBuilder.string(),
+		details: TagTypeBuilder.tuple({
+			age: TagTypeBuilder.uint8(),
+			verified: TagTypeBuilder.bool()
+		}),
+		contact: TagTypeBuilder.tuple({
+			email: TagTypeBuilder.string(),
+			phone: TagTypeBuilder.string()
+		})
+	});
+
+	try {
+		await tagCtx.defineTag('profile', profileType);
+		console.log('✅ Defined "profile" nested tuple tag\n');
+	} catch (error: any) {
+		if (error.message.includes('already been defined')) {
+			console.log('⚠️  "profile" tag already defined, skipping...\n');
+		} else {
+			throw error;
+		}
+	}
+
+	// Set tagger
+	await domain.setTagger('profile', signerAddress);
+	console.log(`✅ Set tagger for "profile" to ${signerAddress}\n`);
+
+	// ========================================
+	// Part 2: Set Nested Tuple using Object
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 2: Set Nested Tuple (Object Notation)');
+	console.log('='.repeat(60));
+
+	const profileValue = {
+		name: 'Alice Johnson',
+		details: {
+			age: 30,
+			verified: true
+		},
+		contact: {
+			email: 'alice@example.com',
+			phone: '+1-555-0123'
+		}
+	};
+
+	console.log('📝 Setting nested tuple with object notation:');
+	console.log(JSON.stringify(profileValue, null, 2));
+
+	await tagCtx.setTag(domainName, 'profile', profileValue);
+	console.log('\n✅ Nested tuple set successfully!\n');
+	await waitForIndexing(3);
+
+	// ========================================
+	// Part 3: Get and Display Nested Tuple
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 3: Read Nested Tuple');
+	console.log('='.repeat(60));
+
+	const profile = await tagCtx.getTag(domainName, 'profile');
+	console.log('📖 Retrieved profile (raw array):');
+	console.log(
+		JSON.stringify(profile, (_, v) =>
+			typeof v === 'bigint' ? v.toString() : v
+		)
+	);
+
+	console.log('\n📖 Retrieved profile (parsed):');
+	console.log(`   name: ${profile[0]}`);
+	console.log(`   details.age: ${profile[1][0]}`);
+	console.log(`   details.verified: ${profile[1][1]}`);
+	console.log(`   contact.email: ${profile[2][0]}`);
+	console.log(`   contact.phone: ${profile[2][1]}\n`);
+
+	// ========================================
+	// Part 4: Update Nested Field
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 4: Update Nested Field');
+	console.log('='.repeat(60));
+
+	console.log('🔄 Updating details.age from 30 to 31...\n');
+
+	const updatedProfile = {
+		name: profile[0],
+		details: {
+			age: 31, // Updated
+			verified: profile[1][1]
+		},
+		contact: {
+			email: profile[2][0],
+			phone: profile[2][1]
+		}
+	};
+
+	await tagCtx.setTag(domainName, 'profile', updatedProfile);
+	console.log('✅ Updated nested field\n');
+	await waitForIndexing(3);
+
+	// Verify update
+	const updatedProfileRead = await tagCtx.getTag(domainName, 'profile');
+	console.log('📖 Verified update:');
+	console.log(
+		`   details.age: ${updatedProfileRead[1][0]} (was 30, now 31)\n`
+	);
+
+	// ========================================
+	// Part 5: Array Notation (Still Supported)
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 5: Array Notation (Alternative)');
+	console.log('='.repeat(60));
+
+	console.log('📝 Setting with array notation (for comparison):\n');
+
+	await tagCtx.setTag(domainName, 'profile', [
+		'Bob Smith', // name
+		[25, false], // details: {age: 25, verified: false}
+		['bob@example.com', '+1-555-9999'] // contact: {email, phone}
+	]);
+
+	console.log('✅ Array notation also works!\n');
+	await waitForIndexing(3);
+
+	const profileArray = await tagCtx.getTag(domainName, 'profile');
+	console.log('📖 Retrieved (set via array notation):');
+	console.log(`   name: ${profileArray[0]}`);
+	console.log(`   details.age: ${profileArray[1][0]}`);
+	console.log(`   details.verified: ${profileArray[1][1]}\n`);
+
+	console.log('='.repeat(60));
+	console.log('✅ All nested tuple operations completed!');
+	console.log('='.repeat(60));
+	console.log('\n💡 Key Takeaways:');
+	console.log('   • Objects are automatically converted to arrays');
+	console.log('   • Nested tuples work seamlessly');
+	console.log('   • No need to provide field names manually');
+	console.log('   • Array notation is still supported for flexibility\n');
+}
+
+main().catch(console.error);

package/examples/tag-simple.ts

@@ -0,0 +1,149 @@
+/**
+ * Simple Tag Example
+ *
+ * This example shows the simplest way to use Tags:
+ * - Define a few simple tags
+ * - Set and get values
+ * - No complex types or arrays
+ *
+ * Prerequisites:
+ * - Set PRIVATE_KEY_OR_MNEMONIC environment variable
+ * - You must own the domain you're operating on
+ *
+ * Run:
+ * export PRIVATE_KEY_OR_MNEMONIC="your private key or mnemonic"
+ * npx ts-node examples/tag-simple.ts <domain-name>
+ */
+
+import OlaresID from '../src/index';
+
+async function main() {
+	// Initialize
+	const olaresId = OlaresID.createTestnet();
+	const privateKeyOrMnemonic = process.env.PRIVATE_KEY_OR_MNEMONIC;
+
+	if (!privateKeyOrMnemonic) {
+		console.error(
+			'❌ Error: PRIVATE_KEY_OR_MNEMONIC environment variable not set'
+		);
+		process.exit(1);
+	}
+
+	await olaresId.setSigner(privateKeyOrMnemonic);
+
+	const domainName = process.argv[2];
+	if (!domainName) {
+		console.error('❌ Error: Please provide a domain name');
+		console.log('Usage: npx ts-node examples/tag-simple.ts <domain-name>');
+		process.exit(1);
+	}
+
+	const domain = olaresId.domain(domainName);
+	const signerAddress = await olaresId.getSigner().getAddress();
+	console.log(`\n🏷️  Simple Tag Example for: ${domainName}`);
+	console.log(`👤 Signer: ${signerAddress}\n`);
+
+	// Step 1: Define tag types (skip if already defined)
+	console.log('1️⃣  Defining tag types...');
+
+	try {
+		await domain.defineSimpleTag('bio', 'string');
+		console.log('   ✅ Defined "bio" (string)');
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+	} catch (error: any) {
+		if (
+			error.message?.includes('RedefinedTag') ||
+			error.message?.includes('already been defined')
+		) {
+			console.log('   ⚠️  "bio" already defined, skipping...');
+		} else {
+			throw error;
+		}
+	}
+
+	try {
+		await domain.defineSimpleTag('followers', 'uint32');
+		console.log('   ✅ Defined "followers" (uint32)');
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+	} catch (error: any) {
+		if (
+			error.message?.includes('RedefinedTag') ||
+			error.message?.includes('already been defined')
+		) {
+			console.log('   ⚠️  "followers" already defined, skipping...');
+		} else {
+			throw error;
+		}
+	}
+
+	try {
+		await domain.defineSimpleTag('premium', 'bool');
+		console.log('   ✅ Defined "premium" (bool)\n');
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+	} catch (error: any) {
+		if (
+			error.message?.includes('RedefinedTag') ||
+			error.message?.includes('already been defined')
+		) {
+			console.log('   ⚠️  "premium" already defined, skipping...\n');
+		} else {
+			throw error;
+		}
+	}
+
+	// Step 2: Set taggers (IMPORTANT!)
+	console.log('2️⃣  Setting taggers (required before setting values)...');
+	await domain.setTagger('bio', signerAddress);
+	console.log('   ✅ Set tagger for "bio"');
+
+	await domain.setTagger('followers', signerAddress);
+	console.log('   ✅ Set tagger for "followers"');
+
+	await domain.setTagger('premium', signerAddress);
+	console.log('   ✅ Set tagger for "premium"\n');
+
+	// Wait for indexing
+	await new Promise((resolve) => setTimeout(resolve, 5000));
+
+	// Step 3: Set values
+	console.log('3️⃣  Setting tag values...');
+	await domain.setTag('bio', 'Web3 developer and blockchain enthusiast');
+	console.log('   ✅ Set "bio"');
+
+	await domain.setTag('followers', 1250);
+	console.log('   ✅ Set "followers"');
+
+	await domain.setTag('premium', true);
+	console.log('   ✅ Set "premium"\n');
+
+	// Wait for indexing
+	await new Promise((resolve) => setTimeout(resolve, 5000));
+
+	// Step 4: Get values
+	console.log('4️⃣  Reading tag values...');
+	const bio = await domain.getTag('bio');
+	const followers = await domain.getTag('followers');
+	const premium = await domain.getTag('premium');
+
+	console.log(`   bio: "${bio}"`);
+	console.log(`   followers: ${followers}`);
+	console.log(`   premium: ${premium}\n`);
+
+	// Step 5: Update a value
+	console.log('5️⃣  Updating "followers" count...');
+	await domain.setTag('followers', 1350);
+	console.log('   ✅ Updated "followers"\n');
+
+	// Wait for indexing
+	await new Promise((resolve) => setTimeout(resolve, 5000));
+
+	const updatedFollowers = await domain.getTag('followers');
+	console.log(`   New followers count: ${updatedFollowers}\n`);
+
+	console.log('✅ Simple Tag Example Completed!\n');
+}
+
+main().catch((error) => {
+	console.error('❌ Error:', error.message);
+	process.exit(1);
+});

package/examples/tag-tagger.ts

@@ -0,0 +1,217 @@
+/**
+ * Tag Tagger Management Example
+ *
+ * This example demonstrates how to set and get taggers (managers) for Tags.
+ * A tagger is an address that has permission to manage a specific Tag.
+ *
+ * Prerequisites:
+ * - Set PRIVATE_KEY_OR_MNEMONIC environment variable (domain owner)
+ * - You must own the domain you're operating on
+ *
+ * Run:
+ * export PRIVATE_KEY_OR_MNEMONIC="your private key or mnemonic"
+ * npx ts-node examples/tag-tagger.ts <domain-name>
+ */
+
+import OlaresID from '../src/index';
+
+async function main() {
+	// Initialize OlaresID
+	const olaresId = OlaresID.createTestnet();
+
+	// Get private key or mnemonic from environment
+	const privateKeyOrMnemonic = process.env.PRIVATE_KEY_OR_MNEMONIC;
+	if (!privateKeyOrMnemonic) {
+		console.error(
+			'❌ Error: PRIVATE_KEY_OR_MNEMONIC environment variable not set'
+		);
+		console.log(
+			'Usage: export PRIVATE_KEY_OR_MNEMONIC="your private key or mnemonic"'
+		);
+		process.exit(1);
+	}
+
+	await olaresId.setSigner(privateKeyOrMnemonic);
+	const signerAddress = await olaresId.getSigner().getAddress();
+	console.log(`✅ Signer address: ${signerAddress}\n`);
+
+	// Get domain name from command line
+	const domainName = process.argv[2];
+	if (!domainName) {
+		console.error('❌ Error: Please provide a domain name');
+		console.log('Usage: npx ts-node examples/tag-tagger.ts <domain-name>');
+		process.exit(1);
+	}
+
+	const domain = olaresId.domain(domainName);
+	console.log(`🏷️  Managing Taggers for domain: ${domainName}\n`);
+
+	// ========================================
+	// Part 1: Define a Tag
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 1: Define a Tag');
+	console.log('='.repeat(60));
+
+	const tagName = 'userStatus';
+
+	try {
+		console.log(`📝 Defining "${tagName}" tag (type: string)...`);
+		await domain.defineSimpleTag(tagName, 'string');
+		console.log(`✅ "${tagName}" tag defined\n`);
+
+		// Wait for indexing
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+	} catch (error: any) {
+		console.error(`❌ Error defining tag: ${error.message}\n`);
+	}
+
+	// ========================================
+	// Part 2: Check Initial Tagger
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 2: Check Initial Tagger');
+	console.log('='.repeat(60));
+
+	try {
+		const initialTagger = await domain.getTagger(tagName);
+		console.log(`📖 Current tagger: ${initialTagger}`);
+
+		if (initialTagger === '0x0000000000000000000000000000000000000000') {
+			console.log('   ℹ️  No specific tagger set (zero address)');
+			console.log('   ℹ️  No one can manage this tag (disabled)\n');
+		} else {
+			console.log(`   ℹ️  Tagger is set to: ${initialTagger}\n`);
+		}
+	} catch (error: any) {
+		console.error(`❌ Error getting tagger: ${error.message}\n`);
+	}
+
+	// ========================================
+	// Part 3: Set a Specific Tagger
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 3: Set a Specific Tagger');
+	console.log('='.repeat(60));
+
+	// Example tagger address (replace with your own)
+	const taggerAddress = '0x1234567890123456789012345678901234567890';
+
+	try {
+		console.log(`📝 Setting tagger to: ${taggerAddress}...`);
+		const result = await domain.setTagger(tagName, taggerAddress);
+		console.log(`✅ Tagger set successfully`);
+		console.log(`   Transaction hash: ${result.transactionHash}\n`);
+
+		// Wait for indexing
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+
+		// Verify the tagger was set
+		const newTagger = await domain.getTagger(tagName);
+		console.log(`📖 Verified tagger: ${newTagger}`);
+
+		if (newTagger.toLowerCase() === taggerAddress.toLowerCase()) {
+			console.log('   ✅ Tagger correctly set!\n');
+		} else {
+			console.log('   ⚠️  Tagger mismatch!\n');
+		}
+	} catch (error: any) {
+		console.error(`❌ Error setting tagger: ${error.message}\n`);
+	}
+
+	// ========================================
+	// Part 4: Set Tagger to Zero Address (Disable Tag Management)
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 4: Set Tagger to Zero Address (Disable Management)');
+	console.log('='.repeat(60));
+
+	const zeroAddress = '0x0000000000000000000000000000000000000000';
+
+	try {
+		console.log(
+			`📝 Setting tagger to zero address (disable management)...`
+		);
+		const result = await domain.setTagger(tagName, zeroAddress);
+		console.log(`✅ Tagger set to zero address`);
+		console.log(`   Transaction hash: ${result.transactionHash}\n`);
+
+		// Wait for indexing
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+
+		// Verify
+		const publicTagger = await domain.getTagger(tagName);
+		console.log(`📖 Verified tagger: ${publicTagger}`);
+
+		if (publicTagger === zeroAddress) {
+			console.log(
+				'   ✅ Tag management is now disabled (no one can set it)!\n'
+			);
+		}
+	} catch (error: any) {
+		console.error(`❌ Error setting tagger to zero: ${error.message}\n`);
+	}
+
+	// ========================================
+	// Part 5: Set Tagger to Self (Owner Only)
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 5: Set Tagger to Self (Owner Only)');
+	console.log('='.repeat(60));
+
+	try {
+		console.log(`📝 Setting tagger to signer address (owner only)...`);
+		const result = await domain.setTagger(tagName, signerAddress);
+		console.log(`✅ Tagger set to: ${signerAddress}`);
+		console.log(`   Transaction hash: ${result.transactionHash}\n`);
+
+		// Wait for indexing
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+
+		// Verify
+		const ownerTagger = await domain.getTagger(tagName);
+		console.log(`📖 Verified tagger: ${ownerTagger}`);
+
+		if (ownerTagger.toLowerCase() === signerAddress.toLowerCase()) {
+			console.log('   ✅ Only the owner can manage this tag now!\n');
+		}
+	} catch (error: any) {
+		console.error(`❌ Error setting tagger to self: ${error.message}\n`);
+	}
+
+	// ========================================
+	// Part 6: Using TagContext (Advanced)
+	// ========================================
+	console.log('='.repeat(60));
+	console.log('Part 6: Using TagContext (Advanced API)');
+	console.log('='.repeat(60));
+
+	try {
+		const tagCtx = domain.tag();
+
+		console.log('📖 Getting tagger using TagContext...');
+		const ctxTagger = await tagCtx.getTagger(tagName);
+		console.log(`   Tagger: ${ctxTagger}`);
+
+		console.log('\n📝 Setting tagger back to zero using TagContext...');
+		const result = await tagCtx.setTagger(tagName, zeroAddress);
+		console.log(`   ✅ Done: ${result.transactionHash}\n`);
+	} catch (error: any) {
+		console.error(`❌ Error with TagContext: ${error.message}\n`);
+	}
+
+	console.log('='.repeat(60));
+	console.log('✅ Tag Tagger Management Example Completed');
+	console.log('='.repeat(60));
+	console.log('\n💡 Key Points:');
+	console.log('   • Only domain owner can set taggers');
+	console.log('   • Zero address = disabled (no one can manage)');
+	console.log('   • Specific address = only that address can manage');
+	console.log('   • Use getTagger() to check who can manage a tag\n');
+}
+
+// Run the example
+main().catch((error) => {
+	console.error('❌ Fatal error:', error);
+	process.exit(1);
+});

package/examples/test-nested-tuple-conversion.ts

@@ -0,0 +1,143 @@
+import { TagAbiCodec } from '../src/utils/tag-abi-codec';
+
+/**
+ * Test script for TagAbiCodec nested tuple conversion
+ * Tests the parseTupleFields and convertObjectToArray functions
+ */
+
+console.log('='.repeat(60));
+console.log('TagAbiCodec Nested Tuple Conversion Test');
+console.log('='.repeat(60));
+
+// Test 1: Simple tuple
+console.log('\n1. Simple Tuple:');
+console.log('   ABI Type: tuple(string,uint8)');
+const obj1 = { name: 'Alice', age: 30 };
+console.log('   Input:', JSON.stringify(obj1));
+const encoded1 = TagAbiCodec.encode('tuple(string,uint8)', obj1);
+console.log('   Encoded:', encoded1);
+const decoded1 = TagAbiCodec.decode('tuple(string,uint8)', encoded1);
+console.log(
+	'   Decoded:',
+	JSON.stringify(decoded1, (_, v) =>
+		typeof v === 'bigint' ? v.toString() : v
+	)
+);
+
+// Test 2: Nested tuple (1 level)
+console.log('\n2. Nested Tuple (1 level):');
+console.log('   ABI Type: tuple(string,tuple(uint8,bool))');
+const obj2 = {
+	name: 'Alice',
+	details: {
+		age: 30,
+		verified: true
+	}
+};
+console.log('   Input:', JSON.stringify(obj2));
+const encoded2 = TagAbiCodec.encode('tuple(string,tuple(uint8,bool))', obj2);
+console.log('   Encoded:', encoded2);
+const decoded2 = TagAbiCodec.decode(
+	'tuple(string,tuple(uint8,bool))',
+	encoded2
+);
+console.log(
+	'   Decoded:',
+	JSON.stringify(decoded2, (_, v) =>
+		typeof v === 'bigint' ? v.toString() : v
+	)
+);
+
+// Test 3: Nested tuple (2 levels)
+console.log('\n3. Nested Tuple (2 levels):');
+console.log(
+	'   ABI Type: tuple(string,tuple(uint8,bool),tuple(string,string))'
+);
+const obj3 = {
+	name: 'Alice',
+	details: {
+		age: 30,
+		verified: true
+	},
+	contact: {
+		email: 'alice@example.com',
+		phone: '+1-555-0123'
+	}
+};
+console.log('   Input:', JSON.stringify(obj3, null, 2));
+const encoded3 = TagAbiCodec.encode(
+	'tuple(string,tuple(uint8,bool),tuple(string,string))',
+	obj3
+);
+console.log('   Encoded:', encoded3);
+const decoded3 = TagAbiCodec.decode(
+	'tuple(string,tuple(uint8,bool),tuple(string,string))',
+	encoded3
+);
+console.log(
+	'   Decoded:',
+	JSON.stringify(
+		decoded3,
+		(_, v) => (typeof v === 'bigint' ? v.toString() : v),
+		2
+	)
+);
+
+// Test 4: Array notation (still supported)
+console.log('\n4. Array Notation (still supported):');
+console.log('   ABI Type: tuple(string,tuple(uint8,bool))');
+const arr4 = ['Bob', [25, false]];
+console.log('   Input:', JSON.stringify(arr4));
+const encoded4 = TagAbiCodec.encode('tuple(string,tuple(uint8,bool))', arr4);
+console.log('   Encoded:', encoded4);
+const decoded4 = TagAbiCodec.decode(
+	'tuple(string,tuple(uint8,bool))',
+	encoded4
+);
+console.log(
+	'   Decoded:',
+	JSON.stringify(decoded4, (_, v) =>
+		typeof v === 'bigint' ? v.toString() : v
+	)
+);
+
+// Test 5: Complex nested structure
+console.log('\n5. Complex Nested Structure:');
+console.log('   ABI Type: tuple(string,tuple(tuple(uint8,bool),address))');
+const obj5 = {
+	name: 'Charlie',
+	data: {
+		info: {
+			age: 40,
+			active: true
+		},
+		wallet: '0x1234567890123456789012345678901234567890'
+	}
+};
+console.log('   Input:', JSON.stringify(obj5, null, 2));
+const encoded5 = TagAbiCodec.encode(
+	'tuple(string,tuple(tuple(uint8,bool),address))',
+	obj5
+);
+console.log('   Encoded:', encoded5);
+const decoded5 = TagAbiCodec.decode(
+	'tuple(string,tuple(tuple(uint8,bool),address))',
+	encoded5
+);
+console.log(
+	'   Decoded:',
+	JSON.stringify(
+		decoded5,
+		(_, v) => (typeof v === 'bigint' ? v.toString() : v),
+		2
+	)
+);
+
+console.log('\n' + '='.repeat(60));
+console.log('✅ All tests completed successfully!');
+console.log('='.repeat(60));
+console.log('\n💡 Key Features:');
+console.log('   • Objects are automatically converted to arrays');
+console.log('   • Nested tuples work recursively');
+console.log('   • Array notation is still supported');
+console.log('   • No need to manually provide field names\n');