@beclab/olaresid 0.1.13 → 0.2.1

package/tests/unit/generate-mnemonic.test.ts

@@ -0,0 +1,268 @@
+/**
+ * Unit tests for mnemonic generation and key derivation
+ *
+ * Tests the integration with Trust Wallet Core for:
+ * - Mnemonic generation (12 and 24 words)
+ * - Ethereum address derivation
+ * - DID derivation
+ * - Combined key generation
+ * - Compatibility with TermiPass
+ */
+
+import {
+	generateMnemonic,
+	getEthereumAddressFromMnemonic,
+	getDIDFromMnemonic,
+	generateDIDKeyData,
+	deriveDIDFromMnemonic
+} from '../../src/index';
+
+describe('Mnemonic Generation', () => {
+	describe('generateMnemonic', () => {
+		test('should generate 12-word mnemonic', () => {
+			const mnemonic = generateMnemonic(12);
+			const words = mnemonic.split(' ');
+
+			expect(words.length).toBe(12);
+			expect(mnemonic).toBeTruthy();
+			expect(typeof mnemonic).toBe('string');
+		});
+
+		test('should generate 24-word mnemonic', () => {
+			const mnemonic = generateMnemonic(24);
+			const words = mnemonic.split(' ');
+
+			expect(words.length).toBe(24);
+			expect(mnemonic).toBeTruthy();
+			expect(typeof mnemonic).toBe('string');
+		});
+
+		test('should generate different mnemonics each time', () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			expect(mnemonic1).not.toBe(mnemonic2);
+		});
+
+		test('generated mnemonic should be valid BIP39', () => {
+			const mnemonic = generateMnemonic(12);
+			// Validate format: lowercase words separated by spaces
+			expect(mnemonic).toMatch(/^[a-z]+( [a-z]+)*$/);
+		});
+	});
+
+	describe('Key Derivation from Mnemonic', () => {
+		test('should derive Ethereum address from 12-word mnemonic', async () => {
+			const mnemonic = generateMnemonic(12);
+			const address = await getEthereumAddressFromMnemonic(mnemonic);
+
+			expect(address).toBeTruthy();
+			expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+		});
+
+		test('should derive Ethereum address from 24-word mnemonic', async () => {
+			const mnemonic = generateMnemonic(24);
+			const address = await getEthereumAddressFromMnemonic(mnemonic);
+
+			expect(address).toBeTruthy();
+			expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+		});
+
+		test('should derive DID from 12-word mnemonic', async () => {
+			const mnemonic = generateMnemonic(12);
+			const did = await getDIDFromMnemonic(mnemonic);
+
+			expect(did).toBeTruthy();
+			expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		test('should derive DID from 24-word mnemonic', async () => {
+			const mnemonic = generateMnemonic(24);
+			const did = await getDIDFromMnemonic(mnemonic);
+
+			expect(did).toBeTruthy();
+			expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		test('same mnemonic should produce same keys', async () => {
+			const mnemonic = generateMnemonic(12);
+
+			const address1 = await getEthereumAddressFromMnemonic(mnemonic);
+			const address2 = await getEthereumAddressFromMnemonic(mnemonic);
+
+			const did1 = await getDIDFromMnemonic(mnemonic);
+			const did2 = await getDIDFromMnemonic(mnemonic);
+
+			expect(address1).toBe(address2);
+			expect(did1).toBe(did2);
+		});
+
+		test('different mnemonics should produce different keys', async () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			const address1 = await getEthereumAddressFromMnemonic(mnemonic1);
+			const address2 = await getEthereumAddressFromMnemonic(mnemonic2);
+
+			const did1 = await getDIDFromMnemonic(mnemonic1);
+			const did2 = await getDIDFromMnemonic(mnemonic2);
+
+			expect(address1).not.toBe(address2);
+			expect(did1).not.toBe(did2);
+		});
+	});
+
+	describe('generateDIDKeyData', () => {
+		test('should generate complete key data with 12-word mnemonic', async () => {
+			const keyData = await generateDIDKeyData(12);
+
+			expect(keyData).toBeDefined();
+			expect(keyData.mnemonic).toBeTruthy();
+			expect(keyData.owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(keyData.did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+
+			const words = keyData.mnemonic.split(' ');
+			expect(words.length).toBe(12);
+		});
+
+		test('should generate complete key data with 24-word mnemonic', async () => {
+			const keyData = await generateDIDKeyData(24);
+
+			expect(keyData).toBeDefined();
+			expect(keyData.mnemonic).toBeTruthy();
+			expect(keyData.owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(keyData.did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+
+			const words = keyData.mnemonic.split(' ');
+			expect(words.length).toBe(24);
+		});
+
+		test('generated keys should match individual derivation', async () => {
+			const keyData = await generateDIDKeyData(12);
+
+			const ownerFromMnemonic = await getEthereumAddressFromMnemonic(
+				keyData.mnemonic
+			);
+			const didFromMnemonic = await getDIDFromMnemonic(keyData.mnemonic);
+
+			expect(keyData.owner).toBe(ownerFromMnemonic);
+			expect(keyData.did).toBe(didFromMnemonic);
+		});
+	});
+
+	describe('deriveDIDFromMnemonic', () => {
+		test('should derive both owner and DID in one call', async () => {
+			const mnemonic = generateMnemonic(12);
+			const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
+
+			expect(owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		test('should match individual derivation results', async () => {
+			const mnemonic = generateMnemonic(12);
+
+			const { owner, did } = await deriveDIDFromMnemonic(mnemonic);
+			const ownerIndividual = await getEthereumAddressFromMnemonic(
+				mnemonic
+			);
+			const didIndividual = await getDIDFromMnemonic(mnemonic);
+
+			expect(owner).toBe(ownerIndividual);
+			expect(did).toBe(didIndividual);
+		});
+
+		test('should be performant (complete in reasonable time)', async () => {
+			const mnemonic = generateMnemonic(12);
+			const startTime = Date.now();
+
+			await deriveDIDFromMnemonic(mnemonic);
+
+			const duration = Date.now() - startTime;
+			// Should complete in less than 5 seconds
+			expect(duration).toBeLessThan(5000);
+		});
+	});
+
+	describe('TermiPass Compatibility', () => {
+		test('should derive correct keys from standard test mnemonic', async () => {
+			// Standard BIP39 test mnemonic
+			const testMnemonic =
+				'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+			const { owner, did } = await deriveDIDFromMnemonic(testMnemonic);
+
+			// These values should remain consistent with TermiPass
+			expect(owner).toBeTruthy();
+			expect(owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(did).toBeTruthy();
+			expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		test('derived keys should be deterministic for test mnemonic', async () => {
+			const testMnemonic =
+				'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+			const result1 = await deriveDIDFromMnemonic(testMnemonic);
+			const result2 = await deriveDIDFromMnemonic(testMnemonic);
+
+			expect(result1.owner).toBe(result2.owner);
+			expect(result1.did).toBe(result2.did);
+		});
+	});
+
+	describe('Edge Cases and Error Handling', () => {
+		test('should handle whitespace in mnemonic', async () => {
+			const mnemonic = generateMnemonic(12);
+			const mnemonicWithSpaces = `  ${mnemonic}  `;
+
+			const address1 = await getEthereumAddressFromMnemonic(
+				mnemonic.trim()
+			);
+			const address2 = await getEthereumAddressFromMnemonic(
+				mnemonicWithSpaces.trim()
+			);
+
+			expect(address1).toBe(address2);
+		});
+
+		test('should generate mnemonic with various valid word counts', () => {
+			// BIP39 supports 12, 15, 18, 21, 24 word mnemonics
+			const validCounts = [12, 15, 18, 21, 24];
+
+			validCounts.forEach((count) => {
+				const mnemonic = generateMnemonic(count);
+				const words = mnemonic.split(' ');
+				expect(words.length).toBe(count);
+			});
+		});
+	});
+
+	describe('Performance Tests', () => {
+		test('should generate multiple mnemonics efficiently', () => {
+			const startTime = Date.now();
+
+			for (let i = 0; i < 10; i++) {
+				generateMnemonic(12);
+			}
+
+			const duration = Date.now() - startTime;
+			// Should generate 10 mnemonics in less than 1 second
+			expect(duration).toBeLessThan(1000);
+		});
+
+		test('batch key derivation should be reasonably fast', async () => {
+			const mnemonics = Array.from({ length: 3 }, () =>
+				generateMnemonic(12)
+			);
+
+			const startTime = Date.now();
+
+			await Promise.all(mnemonics.map((m) => deriveDIDFromMnemonic(m)));
+
+			const duration = Date.now() - startTime;
+			// Should derive 3 sets of keys in less than 10 seconds
+			expect(duration).toBeLessThan(10000);
+		});
+	});
+});

package/tests/unit/olares-id-format.test.ts

@@ -0,0 +1,321 @@
+/**
+ * Unit tests for Olares ID format support
+ *
+ * Tests the Olares ID format conversion utilities:
+ * - normalizeToDomain: Converts Olares ID (alice@example.com) to domain (alice.example.com)
+ * - normalizeToOlaresId: Converts domain (alice.example.com) to Olares ID (alice@example.com)
+ *
+ * The Olares ID format uses @ instead of the first dot, making it look like an email address.
+ * Both formats should work identically throughout the SDK.
+ */
+
+import {
+	normalizeToDomain,
+	normalizeToOlaresId
+} from '../../src/utils/olares-id';
+
+describe('Olares ID Format', () => {
+	describe('normalizeToDomain', () => {
+		test('should convert Olares ID to standard domain format', () => {
+			expect(normalizeToDomain('alice@example.com')).toBe(
+				'alice.example.com'
+			);
+			expect(normalizeToDomain('bob@sub.example.com')).toBe(
+				'bob.sub.example.com'
+			);
+			expect(normalizeToDomain('user@olares.com')).toBe(
+				'user.olares.com'
+			);
+		});
+
+		test('should handle already normalized domain format', () => {
+			expect(normalizeToDomain('alice.example.com')).toBe(
+				'alice.example.com'
+			);
+			expect(normalizeToDomain('bob.sub.example.com')).toBe(
+				'bob.sub.example.com'
+			);
+		});
+
+		test('should only convert the first @ symbol', () => {
+			// If there are multiple @, only the first one is converted
+			expect(normalizeToDomain('user@domain@example.com')).toBe(
+				'user.domain@example.com'
+			);
+		});
+
+		test('should handle multi-level domains', () => {
+			expect(normalizeToDomain('alice@example.com')).toBe(
+				'alice.example.com'
+			);
+			expect(normalizeToDomain('bob@sub.example.com')).toBe(
+				'bob.sub.example.com'
+			);
+			expect(normalizeToDomain('user@deep.nested.domain.com')).toBe(
+				'user.deep.nested.domain.com'
+			);
+		});
+
+		test('should be idempotent', () => {
+			const domain = 'alice.example.com';
+			expect(normalizeToDomain(normalizeToDomain(domain))).toBe(domain);
+		});
+	});
+
+	describe('normalizeToOlaresId', () => {
+		test('should convert domain to Olares ID format', () => {
+			expect(normalizeToOlaresId('alice.example.com')).toBe(
+				'alice@example.com'
+			);
+			expect(normalizeToOlaresId('bob.sub.example.com')).toBe(
+				'bob@sub.example.com'
+			);
+		});
+
+		test('should only convert the first dot', () => {
+			expect(normalizeToOlaresId('user.sub.example.com')).toBe(
+				'user@sub.example.com'
+			);
+			expect(normalizeToOlaresId('deep.level.domain.com')).toBe(
+				'deep@level.domain.com'
+			);
+		});
+
+		test('should convert first dot even if @ already exists', () => {
+			// If input already has @, it will still replace the first dot with @
+			expect(normalizeToOlaresId('alice@example.com')).toBe(
+				'alice@example@com'
+			);
+		});
+
+		test('should not be idempotent if applied to Olares ID format', () => {
+			// Applying twice to a domain will double-convert
+			const domain = 'alice.example.com';
+			const olaresId = normalizeToOlaresId(domain); // alice@example.com
+			expect(olaresId).toBe('alice@example.com');
+			// Applying again will replace the dot in "example.com" with @
+			expect(normalizeToOlaresId(olaresId)).toBe('alice@example@com');
+		});
+	});
+
+	describe('Round-trip Conversion', () => {
+		test('should convert back and forth without data loss', () => {
+			const originalDomain = 'alice.example.com';
+			const olaresId = normalizeToOlaresId(originalDomain);
+			const backToDomain = normalizeToDomain(olaresId);
+
+			expect(backToDomain).toBe(originalDomain);
+		});
+
+		test('should handle multi-level domains in round-trip', () => {
+			const domains = [
+				'alice.example.com',
+				'bob.sub.example.com',
+				'user.deep.nested.domain.com'
+			];
+
+			domains.forEach((domain) => {
+				const olaresId = normalizeToOlaresId(domain);
+				const backToDomain = normalizeToDomain(olaresId);
+				expect(backToDomain).toBe(domain);
+			});
+		});
+
+		test('should start with domain, convert to Olares ID, then back', () => {
+			const domain = 'user.example.com';
+			expect(normalizeToDomain(normalizeToOlaresId(domain))).toBe(domain);
+		});
+
+		test('should start with Olares ID, convert to domain, then back', () => {
+			const olaresId = 'user@example.com';
+			expect(normalizeToOlaresId(normalizeToDomain(olaresId))).toBe(
+				olaresId
+			);
+		});
+	});
+
+	describe('Edge Cases', () => {
+		test('should handle empty string', () => {
+			expect(normalizeToDomain('')).toBe('');
+			expect(normalizeToOlaresId('')).toBe('');
+		});
+
+		test('should handle string with no dot or @', () => {
+			expect(normalizeToDomain('nodot')).toBe('nodot');
+			expect(normalizeToOlaresId('nodot')).toBe('nodot');
+		});
+
+		test('should handle string starting with dot', () => {
+			expect(normalizeToDomain('.startswithdot')).toBe('.startswithdot');
+			// normalizeToOlaresId replaces first dot, even if it's at the start
+			expect(normalizeToOlaresId('.startswithdot')).toBe(
+				'@startswithdot'
+			);
+		});
+
+		test('should handle string starting with @', () => {
+			expect(normalizeToDomain('@startswithat')).toBe('.startswithat');
+			expect(normalizeToOlaresId('@startswithat')).toBe('@startswithat');
+		});
+
+		test('should handle single character domains', () => {
+			expect(normalizeToDomain('1@com')).toBe('1.com');
+			expect(normalizeToOlaresId('1.com')).toBe('1@com');
+		});
+
+		test('should handle multiple @ signs (only first is converted)', () => {
+			expect(normalizeToDomain('multiple@at@signs.com')).toBe(
+				'multiple.at@signs.com'
+			);
+		});
+
+		test('should handle domains with numbers', () => {
+			expect(normalizeToDomain('user123@example456.com')).toBe(
+				'user123.example456.com'
+			);
+			expect(normalizeToOlaresId('user123.example456.com')).toBe(
+				'user123@example456.com'
+			);
+		});
+
+		test('should handle domains with hyphens', () => {
+			expect(normalizeToDomain('my-user@my-domain.com')).toBe(
+				'my-user.my-domain.com'
+			);
+			expect(normalizeToOlaresId('my-user.my-domain.com')).toBe(
+				'my-user@my-domain.com'
+			);
+		});
+	});
+
+	describe('Common Test Cases', () => {
+		test('should handle typical Olares domain names', () => {
+			const testCases = [
+				{ olaresId: 'alice@olares.com', domain: 'alice.olares.com' },
+				{ olaresId: 'bob@terminus.io', domain: 'bob.terminus.io' },
+				{
+					olaresId: 'charlie@example.org',
+					domain: 'charlie.example.org'
+				}
+			];
+
+			testCases.forEach(({ olaresId, domain }) => {
+				expect(normalizeToDomain(olaresId)).toBe(domain);
+				expect(normalizeToOlaresId(domain)).toBe(olaresId);
+			});
+		});
+
+		test('should handle subdomains correctly', () => {
+			const testCases = [
+				{
+					olaresId: 'user@sub.example.com',
+					domain: 'user.sub.example.com'
+				},
+				{
+					olaresId: 'app@service.sub.example.com',
+					domain: 'app.service.sub.example.com'
+				}
+			];
+
+			testCases.forEach(({ olaresId, domain }) => {
+				expect(normalizeToDomain(olaresId)).toBe(domain);
+				expect(normalizeToOlaresId(domain)).toBe(olaresId);
+			});
+		});
+	});
+
+	describe('Format Validation', () => {
+		test('normalizeToDomain should always return dot-separated format', () => {
+			const inputs = [
+				'alice@example.com',
+				'bob@sub.example.com',
+				'user.domain.com',
+				'test@deep.nested.domain.com'
+			];
+
+			inputs.forEach((input) => {
+				const result = normalizeToDomain(input);
+				// Result should not contain @ as the first separator
+				if (result.includes('@')) {
+					// If @ exists, it should not be in the position of first separator
+					const firstDotIndex = result.indexOf('.');
+					const firstAtIndex = result.indexOf('@');
+					expect(firstAtIndex).toBeGreaterThan(firstDotIndex);
+				}
+			});
+		});
+
+		test('normalizeToOlaresId should convert first dot to @', () => {
+			const inputs = [
+				'alice.example.com',
+				'bob.sub.example.com',
+				'user.domain.com'
+			];
+
+			inputs.forEach((input) => {
+				const result = normalizeToOlaresId(input);
+				// If input had a dot, result should have @ at that position
+				if (input.includes('.')) {
+					const firstDotIndex = input.indexOf('.');
+					expect(result.charAt(firstDotIndex)).toBe('@');
+				}
+			});
+		});
+	});
+
+	describe('Consistency', () => {
+		test('same input should always produce same output', () => {
+			const domain = 'alice.example.com';
+			const olaresId = 'alice@example.com';
+
+			// Call multiple times to ensure consistency
+			for (let i = 0; i < 10; i++) {
+				expect(normalizeToDomain(olaresId)).toBe(domain);
+				expect(normalizeToOlaresId(domain)).toBe(olaresId);
+			}
+		});
+
+		test('batch conversion should be consistent', () => {
+			const domains = [
+				'user1.example.com',
+				'user2.example.com',
+				'user3.example.com'
+			];
+
+			const olaresIds = domains.map((d) => normalizeToOlaresId(d));
+			const backToDomains = olaresIds.map((o) => normalizeToDomain(o));
+
+			expect(backToDomains).toEqual(domains);
+		});
+	});
+
+	describe('Real-world Scenarios', () => {
+		test('should handle common TLD formats', () => {
+			const tlds = ['com', 'org', 'net', 'io', 'dev'];
+
+			tlds.forEach((tld) => {
+				const domain = `user.example.${tld}`;
+				const olaresId = `user@example.${tld}`;
+
+				expect(normalizeToDomain(olaresId)).toBe(domain);
+				expect(normalizeToOlaresId(domain)).toBe(olaresId);
+			});
+		});
+
+		test('should handle deeply nested domains', () => {
+			const depth5 = 'user.level1.level2.level3.example.com';
+			const olaresId5 = 'user@level1.level2.level3.example.com';
+
+			expect(normalizeToDomain(olaresId5)).toBe(depth5);
+			expect(normalizeToOlaresId(depth5)).toBe(olaresId5);
+		});
+
+		test('should work with real testnet domain format', () => {
+			const testDomain = '1.com';
+			const testOlaresId = '1@com';
+
+			expect(normalizeToDomain(testOlaresId)).toBe(testDomain);
+			expect(normalizeToOlaresId(testDomain)).toBe(testOlaresId);
+		});
+	});
+});