@beclab/olaresid 0.1.13 → 0.2.1

package/tests/unit/crypto-utils.test.ts

@@ -0,0 +1,338 @@
+import {
+	generateMnemonic,
+	getEthereumAddressFromMnemonic,
+	getDIDFromMnemonic,
+	getEVMPrivateKeyFromMnemonic,
+	deriveDIDFromMnemonic,
+	generateDIDKeyData
+} from '../../src/utils/crypto-utils';
+
+/**
+ * Unit tests for crypto utility functions
+ * Tests mnemonic generation, address derivation, DID generation, etc.
+ */
+
+describe('Crypto Utilities', () => {
+	// Test mnemonic for consistent testing
+	const testMnemonic =
+		'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+	// ========================================
+	// Generate Mnemonic
+	// ========================================
+
+	describe('generateMnemonic', () => {
+		it('should generate 12-word mnemonic', () => {
+			const mnemonic = generateMnemonic(12);
+			expect(typeof mnemonic).toBe('string');
+			expect(mnemonic.split(' ').length).toBe(12);
+		});
+
+		it('should generate 24-word mnemonic', () => {
+			const mnemonic = generateMnemonic(24);
+			expect(typeof mnemonic).toBe('string');
+			expect(mnemonic.split(' ').length).toBe(24);
+		});
+
+		it('should generate different mnemonics each time', () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+			expect(mnemonic1).not.toBe(mnemonic2);
+		});
+
+		it('should generate valid BIP39 mnemonics', () => {
+			const mnemonic = generateMnemonic(12);
+			// Check that it's lowercase words separated by spaces
+			expect(mnemonic).toMatch(/^[a-z]+( [a-z]+){11}$/);
+		});
+	});
+
+	// ========================================
+	// Ethereum Address Derivation
+	// ========================================
+
+	describe('getEthereumAddressFromMnemonic', () => {
+		it('should derive Ethereum address from mnemonic', async () => {
+			const address = await getEthereumAddressFromMnemonic(testMnemonic);
+
+			expect(typeof address).toBe('string');
+			expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+		});
+
+		it('should derive consistent address from same mnemonic', async () => {
+			const address1 = await getEthereumAddressFromMnemonic(testMnemonic);
+			const address2 = await getEthereumAddressFromMnemonic(testMnemonic);
+
+			expect(address1).toBe(address2);
+		});
+
+		it('should derive different addresses from different mnemonics', async () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			const address1 = await getEthereumAddressFromMnemonic(mnemonic1);
+			const address2 = await getEthereumAddressFromMnemonic(mnemonic2);
+
+			expect(address1).not.toBe(address2);
+		});
+
+		it('should derive expected address for test mnemonic', async () => {
+			const address = await getEthereumAddressFromMnemonic(testMnemonic);
+			// Known address for this test mnemonic
+			expect(address.toLowerCase()).toBe(
+				'0x9858effd232b4033e47d90003d41ec34ecaeda94'
+			);
+		});
+	});
+
+	// ========================================
+	// DID Derivation
+	// ========================================
+
+	describe('getDIDFromMnemonic', () => {
+		it('should derive DID from mnemonic', async () => {
+			const did = await getDIDFromMnemonic(testMnemonic);
+
+			expect(typeof did).toBe('string');
+			expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		it('should derive consistent DID from same mnemonic', async () => {
+			const did1 = await getDIDFromMnemonic(testMnemonic);
+			const did2 = await getDIDFromMnemonic(testMnemonic);
+
+			expect(did1).toBe(did2);
+		});
+
+		it('should derive different DIDs from different mnemonics', async () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			const did1 = await getDIDFromMnemonic(mnemonic1);
+			const did2 = await getDIDFromMnemonic(mnemonic2);
+
+			expect(did1).not.toBe(did2);
+		});
+	});
+
+	// ========================================
+	// EVM Private Key Derivation
+	// ========================================
+
+	describe('getEVMPrivateKeyFromMnemonic', () => {
+		it('should derive private key from mnemonic', async () => {
+			const privateKey = await getEVMPrivateKeyFromMnemonic(testMnemonic);
+
+			expect(typeof privateKey).toBe('string');
+			expect(privateKey).toMatch(/^0x[a-fA-F0-9]{64}$/);
+		});
+
+		it('should derive consistent private key from same mnemonic', async () => {
+			const privateKey1 = await getEVMPrivateKeyFromMnemonic(
+				testMnemonic
+			);
+			const privateKey2 = await getEVMPrivateKeyFromMnemonic(
+				testMnemonic
+			);
+
+			expect(privateKey1).toBe(privateKey2);
+		});
+
+		it('should derive different private keys from different mnemonics', async () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			const privateKey1 = await getEVMPrivateKeyFromMnemonic(mnemonic1);
+			const privateKey2 = await getEVMPrivateKeyFromMnemonic(mnemonic2);
+
+			expect(privateKey1).not.toBe(privateKey2);
+		});
+	});
+
+	// ========================================
+	// Derive Owner and DID Together
+	// ========================================
+
+	describe('deriveDIDFromMnemonic', () => {
+		it('should derive both owner and DID from mnemonic', async () => {
+			const result = await deriveDIDFromMnemonic(testMnemonic);
+
+			expect(result).toHaveProperty('owner');
+			expect(result).toHaveProperty('did');
+			expect(result.owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(result.did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		it('should derive consistent results from same mnemonic', async () => {
+			const result1 = await deriveDIDFromMnemonic(testMnemonic);
+			const result2 = await deriveDIDFromMnemonic(testMnemonic);
+
+			expect(result1.owner).toBe(result2.owner);
+			expect(result1.did).toBe(result2.did);
+		});
+
+		it('should match individual derivation methods', async () => {
+			const combined = await deriveDIDFromMnemonic(testMnemonic);
+			const separateAddress = await getEthereumAddressFromMnemonic(
+				testMnemonic
+			);
+			const separateDid = await getDIDFromMnemonic(testMnemonic);
+
+			expect(combined.owner).toBe(separateAddress);
+			expect(combined.did).toBe(separateDid);
+		});
+	});
+
+	// ========================================
+	// Generate Complete Key Data
+	// ========================================
+
+	describe('generateDIDKeyData', () => {
+		it('should generate complete key data with 12 words', async () => {
+			const keyData = await generateDIDKeyData(12);
+
+			expect(keyData).toHaveProperty('mnemonic');
+			expect(keyData).toHaveProperty('owner');
+			expect(keyData).toHaveProperty('did');
+
+			expect(keyData.mnemonic.split(' ').length).toBe(12);
+			expect(keyData.owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(keyData.did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		it('should generate complete key data with 24 words', async () => {
+			const keyData = await generateDIDKeyData(24);
+
+			expect(keyData.mnemonic.split(' ').length).toBe(24);
+			expect(keyData.owner).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(keyData.did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		it('should generate unique key data each time', async () => {
+			const keyData1 = await generateDIDKeyData(12);
+			const keyData2 = await generateDIDKeyData(12);
+
+			expect(keyData1.mnemonic).not.toBe(keyData2.mnemonic);
+			expect(keyData1.owner).not.toBe(keyData2.owner);
+			expect(keyData1.did).not.toBe(keyData2.did);
+		});
+
+		it('should have consistent derivation within generated data', async () => {
+			const keyData = await generateDIDKeyData(12);
+
+			// Verify owner matches when derived separately
+			const separateOwner = await getEthereumAddressFromMnemonic(
+				keyData.mnemonic
+			);
+			expect(keyData.owner).toBe(separateOwner);
+
+			// Verify DID matches when derived separately
+			const separateDid = await getDIDFromMnemonic(keyData.mnemonic);
+			expect(keyData.did).toBe(separateDid);
+		});
+	});
+
+	// ========================================
+	// Cross-Validation Tests
+	// ========================================
+
+	describe('Cross-Validation', () => {
+		it('should have consistent address across all derivation methods', async () => {
+			const mnemonic = generateMnemonic(12);
+
+			const address1 = await getEthereumAddressFromMnemonic(mnemonic);
+			const { owner: address2 } = await deriveDIDFromMnemonic(mnemonic);
+			const { owner: address3 } = await generateDIDKeyData(12); // This uses different mnemonic
+
+			// Same mnemonic should produce same address
+			expect(address1).toBe(address2);
+
+			// Different mnemonics should produce different addresses
+			expect(address1).not.toBe(address3);
+		});
+
+		it('should have consistent DID across all derivation methods', async () => {
+			const mnemonic = generateMnemonic(12);
+
+			const did1 = await getDIDFromMnemonic(mnemonic);
+			const { did: did2 } = await deriveDIDFromMnemonic(mnemonic);
+
+			// Same mnemonic should produce same DID
+			expect(did1).toBe(did2);
+		});
+
+		it('should derive matching private key and address', async () => {
+			const { ethers } = await import('ethers');
+
+			const privateKey = await getEVMPrivateKeyFromMnemonic(testMnemonic);
+			const address = await getEthereumAddressFromMnemonic(testMnemonic);
+
+			// Create wallet from private key and verify address matches
+			const wallet = new ethers.Wallet(privateKey);
+			expect(wallet.address).toBe(address);
+		});
+	});
+
+	// ========================================
+	// Edge Cases
+	// ========================================
+
+	describe('Edge Cases', () => {
+		it('should handle 12-word and 24-word mnemonics equally', async () => {
+			const mnemonic12 = generateMnemonic(12);
+			const mnemonic24 = generateMnemonic(24);
+
+			const address12 = await getEthereumAddressFromMnemonic(mnemonic12);
+			const address24 = await getEthereumAddressFromMnemonic(mnemonic24);
+
+			// Both should be valid addresses
+			expect(address12).toMatch(/^0x[a-fA-F0-9]{40}$/);
+			expect(address24).toMatch(/^0x[a-fA-F0-9]{40}$/);
+
+			const did12 = await getDIDFromMnemonic(mnemonic12);
+			const did24 = await getDIDFromMnemonic(mnemonic24);
+
+			// Both should be valid DIDs
+			expect(did12).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+			expect(did24).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+		});
+
+		it('should handle mnemonic with extra whitespace', async () => {
+			// Note: Most implementations trim whitespace before validation
+			// So we test that trimmed mnemonics work correctly
+			const mnemonicWithSpaces = '  ' + testMnemonic + '  ';
+
+			// The crypto-utils functions should handle trimming internally
+			// For now, we verify that trimmed version works
+			const trimmedMnemonic = mnemonicWithSpaces.trim();
+			const address = await getEthereumAddressFromMnemonic(
+				trimmedMnemonic
+			);
+
+			expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+		});
+	});
+
+	// ========================================
+	// Known Test Vectors
+	// ========================================
+
+	describe('Known Test Vectors', () => {
+		it('should match expected values for standard test mnemonic', async () => {
+			const address = await getEthereumAddressFromMnemonic(testMnemonic);
+			const privateKey = await getEVMPrivateKeyFromMnemonic(testMnemonic);
+			const did = await getDIDFromMnemonic(testMnemonic);
+
+			// Known values for "abandon abandon..." mnemonic
+			expect(address.toLowerCase()).toBe(
+				'0x9858effd232b4033e47d90003d41ec34ecaeda94'
+			);
+			expect(privateKey.toLowerCase()).toBe(
+				'0x1ab42cc412b618bdea3a599e3c9bae199ebf030895b039e9db1e30dafb12b727'
+			);
+
+			// DID should be consistent (exact value depends on ed25519 derivation)
+			expect(did).toMatch(/^did:key:z6Mk/);
+		});
+	});
+});

package/tests/unit/ed25519-jwk.test.ts

@@ -0,0 +1,201 @@
+import { generateMnemonic, getEd25519JwkFromMnemonic } from '../../src/index';
+
+/**
+ * Unit tests for Ed25519 JWK generation
+ * Tests Ed25519 key pair derivation from mnemonic and JWK format conversion
+ */
+
+describe('Ed25519 JWK Generation', () => {
+	// Test mnemonic for consistent testing
+	const testMnemonic =
+		'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+	// ========================================
+	// Basic JWK Generation
+	// ========================================
+
+	describe('getEd25519JwkFromMnemonic', () => {
+		it('should generate Ed25519 JWK from mnemonic', async () => {
+			const result = await getEd25519JwkFromMnemonic(testMnemonic);
+
+			expect(result).toHaveProperty('publicJwk');
+			expect(result).toHaveProperty('privateJwk');
+		});
+
+		it('should generate valid public JWK structure', async () => {
+			const { publicJwk } = await getEd25519JwkFromMnemonic(testMnemonic);
+
+			expect(publicJwk).toHaveProperty('kty', 'OKP');
+			expect(publicJwk).toHaveProperty('crv', 'Ed25519');
+			expect(publicJwk).toHaveProperty('x');
+			expect(typeof publicJwk.x).toBe('string');
+			expect(publicJwk.x.length).toBeGreaterThan(0);
+		});
+
+		it('should generate valid private JWK structure', async () => {
+			const { privateJwk } = await getEd25519JwkFromMnemonic(
+				testMnemonic
+			);
+
+			expect(privateJwk).toHaveProperty('kty', 'OKP');
+			expect(privateJwk).toHaveProperty('crv', 'Ed25519');
+			expect(privateJwk).toHaveProperty('x');
+			expect(privateJwk).toHaveProperty('d');
+			expect(typeof privateJwk.x).toBe('string');
+			expect(typeof privateJwk.d).toBe('string');
+			expect(privateJwk.x.length).toBeGreaterThan(0);
+			expect(privateJwk.d.length).toBeGreaterThan(0);
+		});
+
+		it('should have matching public key in both JWKs', async () => {
+			const { publicJwk, privateJwk } = await getEd25519JwkFromMnemonic(
+				testMnemonic
+			);
+
+			// The public key component (x) should match in both JWKs
+			expect(publicJwk.x).toBe(privateJwk.x);
+		});
+
+		it('should generate consistent JWKs from same mnemonic', async () => {
+			const result1 = await getEd25519JwkFromMnemonic(testMnemonic);
+			const result2 = await getEd25519JwkFromMnemonic(testMnemonic);
+
+			expect(result1.publicJwk.x).toBe(result2.publicJwk.x);
+			expect(result1.privateJwk.x).toBe(result2.privateJwk.x);
+			expect(result1.privateJwk.d).toBe(result2.privateJwk.d);
+		});
+
+		it('should generate different JWKs from different mnemonics', async () => {
+			const mnemonic1 = generateMnemonic(12);
+			const mnemonic2 = generateMnemonic(12);
+
+			const result1 = await getEd25519JwkFromMnemonic(mnemonic1);
+			const result2 = await getEd25519JwkFromMnemonic(mnemonic2);
+
+			expect(result1.publicJwk.x).not.toBe(result2.publicJwk.x);
+			expect(result1.privateJwk.d).not.toBe(result2.privateJwk.d);
+		});
+	});
+
+	// ========================================
+	// JWK Format Validation
+	// ========================================
+
+	describe('JWK Format Validation', () => {
+		it('should generate RFC 7517 compliant public JWK', async () => {
+			const { publicJwk } = await getEd25519JwkFromMnemonic(testMnemonic);
+
+			// RFC 7517: Public key must have kty, crv, x
+			expect(publicJwk.kty).toBe('OKP');
+			expect(publicJwk.crv).toBe('Ed25519');
+			expect(publicJwk.x).toBeDefined();
+
+			// Public JWK should NOT have private key component (d)
+			expect(publicJwk).not.toHaveProperty('d');
+		});
+
+		it('should generate RFC 7517 compliant private JWK', async () => {
+			const { privateJwk } = await getEd25519JwkFromMnemonic(
+				testMnemonic
+			);
+
+			// RFC 7517: Private key must have kty, crv, x, d
+			expect(privateJwk.kty).toBe('OKP');
+			expect(privateJwk.crv).toBe('Ed25519');
+			expect(privateJwk.x).toBeDefined();
+			expect(privateJwk.d).toBeDefined();
+		});
+
+		it('should use base64url encoding for key components', async () => {
+			const { publicJwk, privateJwk } = await getEd25519JwkFromMnemonic(
+				testMnemonic
+			);
+
+			// Base64url should not contain +, /, or =
+			expect(publicJwk.x).not.toMatch(/[+/=]/);
+			expect(privateJwk.x).not.toMatch(/[+/=]/);
+			expect(privateJwk.d).not.toMatch(/[+/=]/);
+		});
+	});
+
+	// ========================================
+	// Integration with Other Functions
+	// ========================================
+
+	describe('Integration Tests', () => {
+		it('should work with generated mnemonics', async () => {
+			const mnemonic = generateMnemonic(12);
+			const { publicJwk, privateJwk } = await getEd25519JwkFromMnemonic(
+				mnemonic
+			);
+
+			expect(publicJwk.x).toBeDefined();
+			expect(privateJwk.d).toBeDefined();
+		});
+
+		it('should work with 12-word and 24-word mnemonics', async () => {
+			const mnemonic12 = generateMnemonic(12);
+			const mnemonic24 = generateMnemonic(24);
+
+			const result12 = await getEd25519JwkFromMnemonic(mnemonic12);
+			const result24 = await getEd25519JwkFromMnemonic(mnemonic24);
+
+			// Both should generate valid JWKs
+			expect(result12.publicJwk.kty).toBe('OKP');
+			expect(result24.publicJwk.kty).toBe('OKP');
+
+			// Should be different keys
+			expect(result12.publicJwk.x).not.toBe(result24.publicJwk.x);
+		});
+	});
+
+	// ========================================
+	// Known Test Vectors
+	// ========================================
+
+	describe('Known Test Vectors', () => {
+		it('should generate expected JWK for standard test mnemonic', async () => {
+			const { publicJwk, privateJwk } = await getEd25519JwkFromMnemonic(
+				testMnemonic
+			);
+
+			// Verify structure
+			expect(publicJwk.kty).toBe('OKP');
+			expect(publicJwk.crv).toBe('Ed25519');
+			expect(privateJwk.kty).toBe('OKP');
+			expect(privateJwk.crv).toBe('Ed25519');
+
+			// Public and private JWK should have matching public key
+			expect(publicJwk.x).toBe(privateJwk.x);
+
+			// Keys should be valid base64url
+			expect(publicJwk.x).toMatch(/^[A-Za-z0-9_-]+$/);
+			expect(privateJwk.d).toMatch(/^[A-Za-z0-9_-]+$/);
+		});
+	});
+
+	// ========================================
+	// Security Tests
+	// ========================================
+
+	describe('Security Tests', () => {
+		it('should generate different keys for different mnemonics', async () => {
+			const result1 = await getEd25519JwkFromMnemonic(testMnemonic);
+			const result2 = await getEd25519JwkFromMnemonic(
+				generateMnemonic(12)
+			);
+
+			// Keys should be completely different
+			expect(result1.publicJwk.x).not.toBe(result2.publicJwk.x);
+			expect(result1.privateJwk.d).not.toBe(result2.privateJwk.d);
+		});
+
+		it('should not expose private key in public JWK', async () => {
+			const { publicJwk } = await getEd25519JwkFromMnemonic(testMnemonic);
+
+			// Ensure private key component is not present
+			expect(publicJwk.d).toBeUndefined();
+			expect(Object.keys(publicJwk)).not.toContain('d');
+		});
+	});
+});