@beclab/olaresid 0.1.1 → 0.1.2

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/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'
+	}
+};

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

@@ -0,0 +1,43 @@
+/* eslint-disable */
+/**
+ * THIS FILE IS GENERATED AUTOMATICALLY.
+ * DO NOT EDIT.
+ *
+ * You are probably looking on adding startup/initialization code.
+ * Use "quasar new boot <name>" and add it there.
+ * One boot file per concern. Then reference the file(s) in quasar.config.js > boot:
+ * boot: ['file', ...] // do not add ".js" extension to it.
+ *
+ * Boot files are your "main.js"
+ **/
+
+import { Quasar } from 'quasar';
+import { markRaw } from 'vue';
+import RootComponent from 'app/src/App.vue';
+
+import createRouter from 'app/src/router/index';
+
+export default async function (createAppFn, quasarUserOptions) {
+	// Create the app instance.
+	// Here we inject into it the Quasar UI, the router & possibly the store.
+	const app = createAppFn(RootComponent);
+
+	app.config.performance = true;
+
+	app.use(Quasar, quasarUserOptions);
+
+	const router = markRaw(
+		typeof createRouter === 'function'
+			? await createRouter({})
+			: createRouter
+	);
+
+	// Expose the app, the router and the store.
+	// Note that we are not mounting the app here, since bootstrapping will be
+	// different depending on whether we are in a browser or on the server.
+	return {
+		app,
+
+		router
+	};
+}

package/examples/quasar-demo/.quasar/client-entry.js

@@ -0,0 +1,38 @@
+/* eslint-disable */
+/**
+ * THIS FILE IS GENERATED AUTOMATICALLY.
+ * DO NOT EDIT.
+ *
+ * You are probably looking on adding startup/initialization code.
+ * Use "quasar new boot <name>" and add it there.
+ * One boot file per concern. Then reference the file(s) in quasar.config.js > boot:
+ * boot: ['file', ...] // do not add ".js" extension to it.
+ *
+ * Boot files are your "main.js"
+ **/
+
+import { createApp } from 'vue';
+
+import '@quasar/extras/roboto-font/roboto-font.css';
+
+import '@quasar/extras/material-icons/material-icons.css';
+
+// We load Quasar stylesheet file
+import 'quasar/dist/quasar.css';
+
+import 'src/css/app.scss';
+
+import createQuasarApp from './app.js';
+import quasarUserOptions from './quasar-user-options.js';
+
+console.info('[Quasar] Running SPA.');
+
+const publicPath = `/`;
+
+async function start({ app, router }) {
+	app.use(router);
+
+	app.mount('#q-app');
+}
+
+createQuasarApp(createApp, quasarUserOptions).then(start);

package/examples/quasar-demo/.quasar/client-prefetch.js

@@ -0,0 +1,130 @@
+/* eslint-disable */
+/**
+ * THIS FILE IS GENERATED AUTOMATICALLY.
+ * DO NOT EDIT.
+ *
+ * You are probably looking on adding startup/initialization code.
+ * Use "quasar new boot <name>" and add it there.
+ * One boot file per concern. Then reference the file(s) in quasar.config.js > boot:
+ * boot: ['file', ...] // do not add ".js" extension to it.
+ *
+ * Boot files are your "main.js"
+ **/
+
+import App from 'app/src/App.vue';
+let appPrefetch =
+	typeof App.preFetch === 'function'
+		? App.preFetch
+		: // Class components return the component options (and the preFetch hook) inside __c property
+		App.__c !== void 0 && typeof App.__c.preFetch === 'function'
+		? App.__c.preFetch
+		: false;
+
+function getMatchedComponents(to, router) {
+	const route = to
+		? to.matched
+			? to
+			: router.resolve(to).route
+		: router.currentRoute.value;
+
+	if (!route) {
+		return [];
+	}
+
+	const matched = route.matched.filter((m) => m.components !== void 0);
+
+	if (matched.length === 0) {
+		return [];
+	}
+
+	return Array.prototype.concat.apply(
+		[],
+		matched.map((m) => {
+			return Object.keys(m.components).map((key) => {
+				const comp = m.components[key];
+				return {
+					path: m.path,
+					c: comp
+				};
+			});
+		})
+	);
+}
+
+export function addPreFetchHooks({ router, publicPath }) {
+	// Add router hook for handling preFetch.
+	// Doing it after initial route is resolved so that we don't double-fetch
+	// the data that we already have. Using router.beforeResolve() so that all
+	// async components are resolved.
+	router.beforeResolve((to, from, next) => {
+		const urlPath = window.location.href.replace(
+				window.location.origin,
+				''
+			),
+			matched = getMatchedComponents(to, router),
+			prevMatched = getMatchedComponents(from, router);
+
+		let diffed = false;
+		const preFetchList = matched
+			.filter((m, i) => {
+				return (
+					diffed ||
+					(diffed =
+						!prevMatched[i] ||
+						prevMatched[i].c !== m.c ||
+						m.path.indexOf('/:') > -1) // does it has params?
+				);
+			})
+			.filter(
+				(m) =>
+					m.c !== void 0 &&
+					(typeof m.c.preFetch === 'function' ||
+						// Class components return the component options (and the preFetch hook) inside __c property
+						(m.c.__c !== void 0 &&
+							typeof m.c.__c.preFetch === 'function'))
+			)
+			.map((m) => (m.c.__c !== void 0 ? m.c.__c.preFetch : m.c.preFetch));
+
+		if (appPrefetch !== false) {
+			preFetchList.unshift(appPrefetch);
+			appPrefetch = false;
+		}
+
+		if (preFetchList.length === 0) {
+			return next();
+		}
+
+		let hasRedirected = false;
+		const redirect = (url) => {
+			hasRedirected = true;
+			next(url);
+		};
+		const proceed = () => {
+			if (hasRedirected === false) {
+				next();
+			}
+		};
+
+		preFetchList
+			.reduce(
+				(promise, preFetch) =>
+					promise.then(
+						() =>
+							hasRedirected === false &&
+							preFetch({
+								currentRoute: to,
+								previousRoute: from,
+								redirect,
+								urlPath,
+								publicPath
+							})
+					),
+				Promise.resolve()
+			)
+			.then(proceed)
+			.catch((e) => {
+				console.error(e);
+				proceed();
+			});
+	});
+}