@beclab/olaresid 0.1.1 → 0.1.3

package/examples/generate-mnemonic.ts

@@ -0,0 +1,149 @@
+/**
+ * Example: Generate mnemonic and derive keys using Trust Wallet Core
+ *
+ * This implementation is compatible with TermiPass and the entire Olares ecosystem.
+ * It uses Trust Wallet Core for key derivation, ensuring consistency across all projects.
+ */
+
+import {
+	generateMnemonic,
+	getEthereumAddressFromMnemonic,
+	getDIDFromMnemonic,
+	generateDIDKeyData,
+	deriveDIDFromMnemonic
+} from '../src/index';
+
+async function example1_generateNew() {
+	console.log('='.repeat(60));
+	console.log('Example 1: Generate New Mnemonic and Keys');
+	console.log('Using Trust Wallet Core (Same as TermiPass)');
+	console.log('='.repeat(60));
+
+	// Generate a 12-word mnemonic
+	console.log('\n🔑 Generating 12-word mnemonic...');
+	const mnemonic12 = generateMnemonic(12);
+	console.log(`Mnemonic: ${mnemonic12}`);
+
+	console.log('\n⏳ Deriving keys using Trust Wallet Core...');
+	const owner12 = await getEthereumAddressFromMnemonic(mnemonic12);
+	const did12 = await getDIDFromMnemonic(mnemonic12);
+
+	console.log('\n✅ Derived keys:');
+	console.log(`  Ethereum Address: ${owner12}`);
+	console.log(`  DID: ${did12}`);
+
+	// Generate a 24-word mnemonic
+	console.log('\n' + '-'.repeat(60));
+	console.log('\n🔑 Generating 24-word mnemonic...');
+	const mnemonic24 = generateMnemonic(24);
+	console.log(`Mnemonic: ${mnemonic24}`);
+
+	console.log('\n⏳ Deriving keys...');
+	const owner24 = await getEthereumAddressFromMnemonic(mnemonic24);
+	const did24 = await getDIDFromMnemonic(mnemonic24);
+
+	console.log('\n✅ Derived keys:');
+	console.log(`  Ethereum Address: ${owner24}`);
+	console.log(`  DID: ${did24}`);
+}
+
+async function example2_useGenerateDIDKeyData() {
+	console.log('\n\n' + '='.repeat(60));
+	console.log('Example 2: Generate Everything at Once');
+	console.log('='.repeat(60));
+
+	console.log('\n⏳ Generating mnemonic and deriving keys...');
+	const keyData = await generateDIDKeyData(12);
+
+	console.log('\n✅ Generated DID Key Data:');
+	console.log(`  Mnemonic: ${keyData.mnemonic}`);
+	console.log(`  Owner (Ethereum): ${keyData.owner}`);
+	console.log(`  DID: ${keyData.did}`);
+}
+
+async function example3_testCompatibility() {
+	console.log('\n\n' + '='.repeat(60));
+	console.log('Example 3: Verify Compatibility with TermiPass');
+	console.log('='.repeat(60));
+
+	// Use the same test mnemonic as in TermiPass
+	const testMnemonic =
+		'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+	console.log(`\n📝 Input mnemonic (standard test mnemonic):`);
+	console.log(testMnemonic);
+
+	try {
+		console.log('\n⏳ Deriving keys using Trust Wallet Core...');
+		const { owner, did } = await deriveDIDFromMnemonic(testMnemonic);
+
+		console.log('\n✅ Derived keys:');
+		console.log(`  Ethereum Address: ${owner}`);
+		console.log(`  DID: ${did}`);
+
+		console.log('\n💡 Note: These keys should match with TermiPass output');
+		console.log(
+			'   You can verify this by running the same mnemonic in TermiPass'
+		);
+	} catch (error: any) {
+		console.error(`\n❌ Error: ${error.message}`);
+	}
+}
+
+async function example4_parallelDerivation() {
+	console.log('\n\n' + '='.repeat(60));
+	console.log('Example 4: Parallel Key Derivation (Performance Test)');
+	console.log('='.repeat(60));
+
+	const mnemonic = generateMnemonic(12);
+	console.log(`\n📝 Mnemonic: ${mnemonic}`);
+
+	console.log('\n⏳ Deriving owner and DID in parallel...');
+	const startTime = Date.now();
+
+	const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
+
+	const endTime = Date.now();
+	const duration = endTime - startTime;
+
+	console.log('\n✅ Results:');
+	console.log(`  Owner: ${owner}`);
+	console.log(`  DID: ${did}`);
+	console.log(`  Time taken: ${duration}ms`);
+}
+
+async function main() {
+	console.log('🔐 Trust Wallet Core Integration - Key Generation Examples\n');
+	console.log('This implementation ensures compatibility with TermiPass');
+	console.log('and the entire Olares ecosystem.\n');
+
+	try {
+		await example1_generateNew();
+		await example2_useGenerateDIDKeyData();
+		await example3_testCompatibility();
+		await example4_parallelDerivation();
+
+		console.log('\n\n' + '='.repeat(60));
+		console.log('✅ All examples completed successfully!');
+		console.log('='.repeat(60));
+		console.log(
+			'\n⚠️  SECURITY WARNING: Never share your mnemonic phrase!'
+		);
+		console.log(
+			'    Store it securely and never commit it to version control.'
+		);
+		console.log(
+			'\n💡 These keys are compatible with TermiPass and other Olares tools.\n'
+		);
+	} catch (error: any) {
+		console.error('\n❌ Error:', error.message || error);
+		if (error.stack) {
+			console.error('\nStack trace:');
+			console.error(error.stack);
+		}
+		process.exit(1);
+	}
+}
+
+// Run the examples
+main();

package/examples/index.ts

@@ -6,7 +6,7 @@ async function main() {
 	const domain = await olaresId.fetchDomain('tw7613781.olares.com');
 	console.log(domain);
 
-	// 获取所有域名数据 (主网上数据量较大，测试网数据量较小，测试的话建议在测试网环境下体验此函数)
+	// Get all domain data (the mainnet has a large amount of data, the testnet has a small amount of data, for testing it is recommended to experience this function in the testnet environment)
 	// await olaresId.fetchAll();
 	// console.log('All Domains:', olaresId.allDomainCache);
 	// console.log('Domain Tree Cache:', olaresId.treesCache);

package/examples/ip.ts

@@ -0,0 +1,171 @@
+import OlaresID, { ipv4ToBytes4, bytes4ToIpv4 } from '../src/index';
+
+async function main() {
+	console.log('='.repeat(60));
+	console.log('Testing DNS A Record (IP) Methods');
+	console.log('='.repeat(60));
+
+	// Test 1: Convert IPv4 to bytes4
+	console.log('\n🔄 Test 1: ipv4ToBytes4()');
+	console.log('-'.repeat(60));
+	try {
+		const testIPs = [
+			'127.0.0.1',
+			'192.168.1.1',
+			'8.8.8.8',
+			'255.255.255.255'
+		];
+
+		for (const ip of testIPs) {
+			const bytes4 = ipv4ToBytes4(ip);
+			console.log(`  ${ip} → ${bytes4}`);
+		}
+		console.log('✅ Successfully converted IPv4 to bytes4');
+	} catch (error) {
+		console.error('❌ Failed:', error);
+	}
+
+	// Test 2: Convert bytes4 to IPv4
+	console.log('\n🔄 Test 2: bytes4ToIpv4()');
+	console.log('-'.repeat(60));
+	try {
+		const testBytes = [
+			'0x7f000001',
+			'0xc0a80101',
+			'0x08080808',
+			'0xffffffff'
+		];
+
+		for (const bytes of testBytes) {
+			const ip = bytes4ToIpv4(bytes);
+			console.log(`  ${bytes} → ${ip}`);
+		}
+		console.log('✅ Successfully converted bytes4 to IPv4');
+	} catch (error) {
+		console.error('❌ Failed:', error);
+	}
+
+	// Test 3: Round-trip conversion
+	console.log('\n🔄 Test 3: Round-trip conversion');
+	console.log('-'.repeat(60));
+	try {
+		const originalIP = '192.168.1.100';
+		const bytes4 = ipv4ToBytes4(originalIP);
+		const convertedIP = bytes4ToIpv4(bytes4);
+
+		console.log(`  Original:  ${originalIP}`);
+		console.log(`  Bytes4:    ${bytes4}`);
+		console.log(`  Converted: ${convertedIP}`);
+
+		if (originalIP === convertedIP) {
+			console.log('✅ Round-trip conversion successful!');
+		} else {
+			console.log('⚠️  Round-trip conversion mismatch');
+		}
+	} catch (error) {
+		console.error('❌ Failed:', error);
+	}
+
+	// Test 4: Blockchain operations
+	if (process.env.PRIVATE_KEY_OR_MNEMONIC) {
+		console.log('\n📝 Test 4: setIP()');
+		console.log('-'.repeat(60));
+
+		const didConsole = OlaresID.createTestnet();
+		await didConsole.setSigner(process.env.PRIVATE_KEY_OR_MNEMONIC);
+
+		const testDomain = '1.com';
+		const domain = didConsole.domain(testDomain);
+		const testIP = '192.168.1.100';
+
+		try {
+			const result = await domain.setIP(testIP);
+
+			if (result.success) {
+				console.log('✅ Success:');
+				console.log('  Transaction Hash:', result.transactionHash);
+				console.log('  Gas Used:', result.gasUsed?.toString());
+
+				// Wait for the blockchain to index the data
+				console.log('⏳ Waiting for blockchain to index data...');
+				await new Promise((resolve) => setTimeout(resolve, 5000));
+			} else {
+				console.log('❌ Failed:', result.error);
+			}
+		} catch (error) {
+			console.error('❌ Failed:', error);
+		}
+
+		// Test 5: Verify IP was set
+		console.log('\n🔍 Test 5: getIP()');
+		console.log('-'.repeat(60));
+		try {
+			const storedIP = await domain.getIP();
+			if (storedIP) {
+				console.log('✅ DNS A Record found on chain:', storedIP);
+
+				if (storedIP === testIP) {
+					console.log('✅ Stored IP matches our original IP!');
+				} else {
+					console.log('⚠️  Stored IP differs from original');
+					console.log('  Expected:', testIP);
+					console.log('  Got:', storedIP);
+				}
+			} else {
+				console.log('❌ No DNS A Record found');
+			}
+		} catch (error) {
+			console.error('❌ Failed:', error);
+		}
+
+		// Test 6: Remove IP
+		console.log('\n🗑️  Test 6: removeIP()');
+		console.log('-'.repeat(60));
+		try {
+			const removeResult = await domain.removeIP();
+
+			if (removeResult.success) {
+				console.log('✅ Success:');
+				console.log(
+					'  Transaction Hash:',
+					removeResult.transactionHash
+				);
+				console.log('  Gas Used:', removeResult.gasUsed?.toString());
+
+				// Wait for the blockchain to index the data
+				console.log('⏳ Waiting for blockchain to index data...');
+				await new Promise((resolve) => setTimeout(resolve, 5000));
+			} else {
+				console.log('❌ Failed:', removeResult.error);
+			}
+		} catch (error) {
+			console.error('❌ Failed:', error);
+		}
+
+		// Test 7: Verify IP was removed
+		console.log('\n🔍 Test 7: Verify IP after removal');
+		console.log('-'.repeat(60));
+		try {
+			const removedIP = await domain.getIP();
+			if (removedIP) {
+				console.log('❌ DNS A Record still exists:', removedIP);
+			} else {
+				console.log('✅ DNS A Record successfully removed');
+			}
+		} catch (error) {
+			console.error('❌ Failed:', error);
+		}
+
+		didConsole.clearSigner();
+	} else {
+		console.log(
+			'\n⚠️  Skipping blockchain tests (no PRIVATE_KEY_OR_MNEMONIC provided)'
+		);
+	}
+
+	console.log('\n' + '='.repeat(60));
+	console.log('✅ All tests completed!');
+	console.log('='.repeat(60));
+}
+
+main().catch(console.error);

package/examples/legacy.ts

@@ -1,16 +1,16 @@
 import DID from '../src/index';
 
-// op sepolia 测试网环境
+// op sepolia testnet environment
 const RPC = 'https://sepolia.optimism.io';
-const CONTRACT_DID = '0xe2D7c3a9013960E04d4E9F5F9B63fff37eEd97A8'; // DID 合约地址
-const CONTRACT_ROOT_RESOLVER = '0xeF727cb066Fee98F88Db84555830063b4A24ddfc'; // RootResolver 合约地址
-const CONTRACT_ABI_TYPE = '0x7386fCBae6Ad4CCE1499d9153D99bc950B589718'; // ABIType 合约地址
+const CONTRACT_DID = '0xe2D7c3a9013960E04d4E9F5F9B63fff37eEd97A8'; // DID contract address
+const CONTRACT_ROOT_RESOLVER = '0xeF727cb066Fee98F88Db84555830063b4A24ddfc'; // RootResolver contract address
+const CONTRACT_ABI_TYPE = '0x7386fCBae6Ad4CCE1499d9153D99bc950B589718'; // ABIType contract address
 
-// // op 主网环境
+// // op mainnet environment
 // const RPC = 'https://optimism-rpc.publicnode.com';
-// const CONTRACT_DID = '0x5DA4Fa8E567d86e52Ef8Da860de1be8f54cae97D'; // DID 合约地址
-// const CONTRACT_ROOT_RESOLVER = '0xE2EABA0979277A90511F8873ae1e8cA26B54E740'; // RootResolver 合约地址
-// const CONTRACT_ABI_TYPE = '0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365'; // ABIType 合约地址
+// const CONTRACT_DID = '0x5DA4Fa8E567d86e52Ef8Da860de1be8f54cae97D'; // DID contract address
+// const CONTRACT_ROOT_RESOLVER = '0xE2EABA0979277A90511F8873ae1e8cA26B54E740'; // RootResolver contract address
+// const CONTRACT_ABI_TYPE = '0x9ae3F16bD99294Af1784beB1a0A5C84bf2636365'; // ABIType contract address
 
 async function main() {
 	const did = DID.createConsole(
@@ -20,11 +20,11 @@ async function main() {
 		CONTRACT_ABI_TYPE
 	);
 
-	// 获取特定域名数据
+	// Get specific domain data
 	const domain = await did.fetchDomain('tw7613781.olares.com');
 	console.log('Domain Data:', domain);
 
-	// 获取所有域名数据 (主网上数据量较大，测试网数据量较小，测试的话建议在测试网环境下体验此函数)
+	// Get all domain data (the mainnet has a large amount of data, the testnet has a small amount of data, for testing it is recommended to experience this function in the testnet environment)
 	await did.fetchAll();
 	console.log('All Domains:', did.allDomainCache);
 	console.log('Domain Tree Cache:', did.treesCache);

package/examples/list-wallets.ts

@@ -0,0 +1,81 @@
+import OlaresID from '../src/index';
+
+/**
+ * Example: List All Wallets for a Domain
+ *
+ * This example shows how to query all authenticated wallet addresses
+ * (both EVM and Solana) for an Olares Name.
+ *
+ * Note: This is a read-only operation, no signer required.
+ *
+ * Optional environment variables:
+ * - DOMAIN_NAME: The Olares Name to query (default: use command line argument)
+ */
+
+async function main() {
+	// Get domain name from environment or command line
+	const domainName = process.env.DOMAIN_NAME || process.argv[2];
+
+	if (!domainName) {
+		console.error('\n❌ Please provide a domain name:');
+		console.error('  node examples/list-wallets.js your.olares');
+		console.error('  OR');
+		console.error(
+			'  export DOMAIN_NAME="your.olares" && node examples/list-wallets.js\n'
+		);
+		process.exit(1);
+	}
+
+	console.log('\n📋 Listing Wallets for Domain\n');
+	console.log(`Domain: ${domainName}\n`);
+
+	// Initialize OlaresID (no signer needed for read operations)
+	// Use createMainnet() for production, createTestnet() for testing
+	const olaresId = OlaresID.createTestnet();
+
+	// Get domain context
+	const domain = olaresId.domain(domainName);
+
+	// Get EVM wallets
+	console.log('⏳ Fetching EVM wallets...');
+	const evmWallets = await domain.getEVMWallets();
+
+	console.log(`\n💰 EVM Wallets (${evmWallets.length}):\n`);
+	if (evmWallets.length === 0) {
+		console.log('  (No EVM wallets found)\n');
+	} else {
+		evmWallets.forEach((addr, i) => {
+			console.log(`  ${i + 1}. ${addr}`);
+		});
+		console.log('');
+	}
+
+	// Get Solana wallets
+	console.log('⏳ Fetching Solana wallets...');
+	const solanaWallets = await domain.getSolanaWallets();
+
+	console.log(`\n🌟 Solana Wallets (${solanaWallets.length}):\n`);
+	if (solanaWallets.length === 0) {
+		console.log('  (No Solana wallets found)\n');
+	} else {
+		solanaWallets.forEach((addr, i) => {
+			console.log(`  ${i + 1}. ${addr}`);
+		});
+		console.log('');
+	}
+
+	// Summary
+	const totalWallets = evmWallets.length + solanaWallets.length;
+	console.log('📊 Summary:');
+	console.log(`  Total: ${totalWallets} wallet(s)`);
+	console.log(`  EVM: ${evmWallets.length}`);
+	console.log(`  Solana: ${solanaWallets.length}`);
+
+	console.log('\n✨ Done!\n');
+}
+
+// Run the example
+main().catch((error) => {
+	console.error('\n❌ Error:', error.message);
+	process.exit(1);
+});

package/examples/olares-id-format.ts

@@ -0,0 +1,197 @@
+/**
+ * Example: Testing Olares ID Format Support
+ *
+ * This example demonstrates the new Olares ID format support.
+ * Olares ID uses @ instead of the first dot, making it look like an email address.
+ *
+ * Format conversion:
+ *   - Standard domain: alice.example.com
+ *   - Olares ID format: alice@example.com
+ *
+ * Both formats should work identically in the SDK and CLI.
+ */
+
+import OlaresID from '../src/index';
+import { normalizeToDomain, normalizeToOlaresId } from '../src/utils/olares-id';
+
+async function main() {
+	console.log('='.repeat(80));
+	console.log('Testing Olares ID Format Support');
+	console.log('='.repeat(80));
+
+	// Test 1: Utility Functions
+	console.log('\n📝 Test 1: Olares ID Utility Functions');
+	console.log('-'.repeat(80));
+
+	const testCases = [
+		{ input: 'alice@example.com', expected: 'alice.example.com' },
+		{ input: 'bob@sub.example.com', expected: 'bob.sub.example.com' },
+		{ input: 'charlie.example.com', expected: 'charlie.example.com' },
+		{ input: 'user@olares.com', expected: 'user.olares.com' }
+	];
+
+	console.log('Testing normalizeToDomain():');
+	for (const test of testCases) {
+		const result = normalizeToDomain(test.input);
+		const status = result === test.expected ? '✅' : '❌';
+		console.log(
+			`  ${status} normalizeToDomain('${test.input}') => '${result}' (expected: '${test.expected}')`
+		);
+	}
+
+	console.log('\nTesting normalizeToOlaresId():');
+	const domainToOlaresIdTests = [
+		{ input: 'alice.example.com', expected: 'alice@example.com' },
+		{ input: 'bob.sub.example.com', expected: 'bob@sub.example.com' }
+	];
+
+	for (const test of domainToOlaresIdTests) {
+		const result = normalizeToOlaresId(test.input);
+		const status = result === test.expected ? '✅' : '❌';
+		console.log(
+			`  ${status} normalizeToOlaresId('${test.input}') => '${result}' (expected: '${test.expected}')`
+		);
+	}
+
+	// Test 2: SDK with Olares ID Format
+	console.log('\n🔧 Test 2: SDK with Olares ID Format');
+	console.log('-'.repeat(80));
+
+	const didConsole = OlaresID.createTestnet();
+
+	// Use a real test domain (1.com is a common test domain on testnet)
+	const testDomainStandard = '1.com';
+	const testDomainOlaresId = '1@com'; // Olares ID format
+
+	console.log('\nTesting with standard domain format:', testDomainStandard);
+	try {
+		const domainStandard = didConsole.domain(testDomainStandard);
+		const metaStandard = await domainStandard.getMetaInfo();
+		console.log('✅ Standard format works:');
+		console.log('  Name:', metaStandard.name);
+		console.log('  DID:', metaStandard.did);
+		console.log('  Owner:', await domainStandard.getOwner());
+	} catch (error) {
+		console.error('❌ Standard format failed:', error);
+	}
+
+	console.log('\nTesting with Olares ID format:', testDomainOlaresId);
+	try {
+		const domainOlaresId = didConsole.domain(testDomainOlaresId);
+		const metaOlaresId = await domainOlaresId.getMetaInfo();
+		console.log('✅ Olares ID format works:');
+		console.log('  Name:', metaOlaresId.name);
+		console.log('  DID:', metaOlaresId.did);
+		console.log('  Owner:', await domainOlaresId.getOwner());
+	} catch (error) {
+		console.error('❌ Olares ID format failed:', error);
+	}
+
+	// Test 3: Verify Both Formats Return Same Data
+	console.log('\n🔍 Test 3: Verify Both Formats Return Same Data');
+	console.log('-'.repeat(80));
+
+	try {
+		const domainStandard = didConsole.domain(testDomainStandard);
+		const domainOlaresId = didConsole.domain(testDomainOlaresId);
+
+		const [metaStandard, metaOlaresId] = await Promise.all([
+			domainStandard.getMetaInfo(),
+			domainOlaresId.getMetaInfo()
+		]);
+
+		const ownerStandard = await domainStandard.getOwner();
+		const ownerOlaresId = await domainOlaresId.getOwner();
+
+		console.log('Comparing results:');
+		console.log(
+			`  Name match: ${
+				metaStandard.name === metaOlaresId.name ? '✅' : '❌'
+			} (${metaStandard.name} vs ${metaOlaresId.name})`
+		);
+		console.log(
+			`  DID match: ${
+				metaStandard.did === metaOlaresId.did ? '✅' : '❌'
+			}`
+		);
+		console.log(
+			`  Owner match: ${
+				ownerStandard === ownerOlaresId ? '✅' : '❌'
+			} (${ownerStandard} vs ${ownerOlaresId})`
+		);
+		console.log(
+			`  TokenId match: ${
+				domainStandard.getTokenId() === domainOlaresId.getTokenId()
+					? '✅'
+					: '❌'
+			}`
+		);
+	} catch (error) {
+		console.error('❌ Comparison failed:', error);
+	}
+
+	// Test 4: Multi-level Domain Support
+	console.log('\n🌳 Test 4: Multi-level Domain Support');
+	console.log('-'.repeat(80));
+
+	const multiLevelTests = [
+		{ standard: 'alice.example.com', olaresId: 'alice@example.com' },
+		{ standard: 'bob.sub.example.com', olaresId: 'bob@sub.example.com' },
+		{
+			standard: 'user.deep.nested.domain.com',
+			olaresId: 'user@deep.nested.domain.com'
+		}
+	];
+
+	for (const test of multiLevelTests) {
+		const normalized = normalizeToDomain(test.olaresId);
+		const matches = normalized === test.standard;
+		console.log(
+			`  ${matches ? '✅' : '❌'} ${
+				test.olaresId
+			} => ${normalized} (expected: ${test.standard})`
+		);
+	}
+
+	// Test 5: Edge Cases
+	console.log('\n⚠️  Test 5: Edge Cases');
+	console.log('-'.repeat(80));
+
+	const edgeCases = [
+		{ input: '', description: 'Empty string' },
+		{ input: 'nodot', description: 'No dot or @' },
+		{
+			input: 'multiple@at@signs.com',
+			description: 'Multiple @ signs (only first is converted)'
+		},
+		{ input: '.startswithdot', description: 'Starts with dot' },
+		{ input: '@startswithat', description: 'Starts with @' }
+	];
+
+	for (const test of edgeCases) {
+		try {
+			const result = normalizeToDomain(test.input);
+			console.log(
+				`  ℹ️  ${test.description}: '${test.input}' => '${result}'`
+			);
+		} catch (error) {
+			console.log(`  ℹ️  ${test.description}: Error - ${error}`);
+		}
+	}
+
+	console.log('\n' + '='.repeat(80));
+	console.log('✅ All Olares ID format tests completed!');
+	console.log('='.repeat(80));
+	console.log('\n💡 Key Takeaways:');
+	console.log(
+		'  • Both standard domain and Olares ID formats work identically'
+	);
+	console.log(
+		'  • Use alice@example.com instead of alice.example.com for a more intuitive format'
+	);
+	console.log('  • The conversion happens automatically in the SDK and CLI');
+	console.log('  • Only the first dot/@ is affected by the conversion');
+	console.log('='.repeat(80));
+}
+
+main().catch(console.error);

package/examples/quasar-demo/.eslintrc.js

@@ -0,0 +1,23 @@
+module.exports = {
+	root: true,
+	parserOptions: {
+		parser: '@typescript-eslint/parser',
+		ecmaVersion: 2021
+	},
+	env: {
+		browser: true,
+		es2021: true,
+		node: true
+	},
+	extends: [
+		'plugin:vue/vue3-essential',
+		'eslint:recommended',
+		'@vue/typescript/recommended',
+		'prettier'
+	],
+	plugins: ['vue', '@typescript-eslint'],
+	rules: {
+		'@typescript-eslint/no-explicit-any': 'off',
+		'@typescript-eslint/no-unused-vars': 'warn'
+	}
+};