pwc-sdk-wallet 0.6.9 → 0.7.1

package/dist/Vault.js

@@ -48,12 +48,45 @@ class Vault {
      * @throws Error if mnemonic generation or keyring initialization fails
      */
     static async createNew(password, chainType = 'evm', config) {
+        // ADD LOG HERE: Input parameters
+        console.log('[VAULT_CREATE] Input:', {
+            password: password,
+            passwordLength: password.length,
+            chainType,
+            config: config,
+            hasConfig: !!config,
+            configKeys: config ? Object.keys(config) : []
+        });
         const mnemonic = EncryptionService_1.EncryptionService.generateMnemonic();
         if (chainType === 'solana') {
             const solanaKeyring = new SolanaKeyring_1.SolanaKeyring(mnemonic);
             const vault = new Vault([solanaKeyring], config);
             vault.chainId = 'solana'; // Set Solana chain ID
             const encryptedVault = await vault.encrypt(password);
+            // ADD LOG HERE: After encrypt
+            console.log('[VAULT_CREATE] Encrypted output:', {
+                encryptedData: encryptedVault.encryptedData,
+                encryptedDataLength: encryptedVault.encryptedData.length,
+                iv: encryptedVault.iv,
+                ivLength: encryptedVault.iv.length,
+                salt: encryptedVault.salt,
+                saltLength: encryptedVault.salt.length
+            });
+            // ADD LOG HERE: Decrypt để so sánh
+            const decryptedString = await EncryptionService_1.EncryptionService.decrypt(encryptedVault, password);
+            console.log('[VAULT_CREATE] Decrypted content:', {
+                decryptedString: decryptedString,
+                decryptedStringLength: decryptedString.length,
+                isJsonValid: (() => {
+                    try {
+                        JSON.parse(decryptedString);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                })()
+            });
             return { vault, encryptedVault };
         }
         else {
@@ -62,6 +95,30 @@ class Vault {
             const vault = new Vault([hdKeyring], config);
             vault.chainId = '1'; // Set Ethereum mainnet as default
             const encryptedVault = await vault.encrypt(password);
+            // ADD LOG HERE: After encrypt
+            console.log('[VAULT_CREATE] Encrypted output:', {
+                encryptedData: encryptedVault.encryptedData,
+                encryptedDataLength: encryptedVault.encryptedData.length,
+                iv: encryptedVault.iv,
+                ivLength: encryptedVault.iv.length,
+                salt: encryptedVault.salt,
+                saltLength: encryptedVault.salt.length
+            });
+            // ADD LOG HERE: Decrypt để so sánh
+            const decryptedString = await EncryptionService_1.EncryptionService.decrypt(encryptedVault, password);
+            console.log('[VAULT_CREATE] Decrypted content:', {
+                decryptedString: decryptedString,
+                decryptedStringLength: decryptedString.length,
+                isJsonValid: (() => {
+                    try {
+                        JSON.parse(decryptedString);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                })()
+            });
             return { vault, encryptedVault };
         }
     }
@@ -98,18 +155,138 @@ class Vault {
      * @throws Error if password is incorrect or decryption fails
      */
     static async load(password, encryptedVault, config) {
+        // ADD LOG HERE: Input parameters
+        console.log('[VAULT_LOAD] Input:', {
+            password: password,
+            passwordLength: password.length,
+            encryptedData: encryptedVault.encryptedData,
+            encryptedDataLength: encryptedVault.encryptedData.length,
+            iv: encryptedVault.iv,
+            ivLength: encryptedVault.iv.length,
+            salt: encryptedVault.salt,
+            saltLength: encryptedVault.salt.length,
+            config: config,
+            hasConfig: !!config,
+            configKeys: config ? Object.keys(config) : []
+        });
         const decryptedString = await EncryptionService_1.EncryptionService.decrypt(encryptedVault, password);
-        const serializedKeyrings = JSON.parse(decryptedString);
+        // ADD LOG HERE: After decrypt
+        console.log('[VAULT_LOAD] Decrypted content:', {
+            decryptedString: decryptedString,
+            decryptedStringLength: decryptedString.length,
+            isJsonValid: (() => {
+                try {
+                    JSON.parse(decryptedString);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            })()
+        });
+        // ADD LOG HERE: Compare with expected format
+        const expectedFormat = '[{"type":"HD","mnemonic":"...","accounts":["..."]}]';
+        console.log('[VAULT_LOAD] Expected format check:', {
+            startsWithBracket: decryptedString.startsWith('['),
+            endsWithBracket: decryptedString.endsWith(']'),
+            containsType: decryptedString.includes('"type"'),
+            containsMnemonic: decryptedString.includes('"mnemonic"'),
+            containsAccounts: decryptedString.includes('"accounts"'),
+            expectedFormat: expectedFormat
+        });
+        let serializedKeyrings;
+        try {
+            serializedKeyrings = JSON.parse(decryptedString);
+        }
+        catch (error) {
+            console.error('[VAULT_LOAD] FAILED HERE: JSON parse failed');
+            console.error('[VAULT_LOAD] FAILED DATA:', {
+                decryptedString: decryptedString,
+                decryptedStringLength: decryptedString.length,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // ADD LOG HERE: Analyze what's wrong with the data
+            console.error('[VAULT_LOAD] DATA ANALYSIS:', {
+                isNull: decryptedString === null,
+                isUndefined: decryptedString === undefined,
+                isEmpty: decryptedString === '',
+                isString: typeof decryptedString === 'string',
+                firstChar: decryptedString ? decryptedString.charAt(0) : 'N/A',
+                lastChar: decryptedString ? decryptedString.charAt(decryptedString.length - 1) : 'N/A',
+                containsSpecialChars: decryptedString ? /[^\x00-\x7F]/.test(decryptedString) : false,
+                containsControlChars: decryptedString ? /[\x00-\x1F\x7F]/.test(decryptedString) : false
+            });
+            throw error;
+        }
+        // ADD LOG HERE: After JSON parse
+        console.log('[VAULT_LOAD] Parsed keyrings:', {
+            keyringCount: serializedKeyrings.length,
+            keyringTypes: serializedKeyrings.map((k) => k.type),
+            keyringDetails: serializedKeyrings.map((k) => ({
+                type: k.type,
+                hasMnemonic: !!k.mnemonic,
+                hasAccounts: !!k.accounts,
+                accountsCount: k.accounts ? k.accounts.length : 0
+            }))
+        });
+        // ADD LOG HERE: Validate keyring structure
+        serializedKeyrings.forEach((keyring, index) => {
+            console.log(`[VAULT_LOAD] Keyring ${index} validation:`, {
+                hasType: !!keyring.type,
+                type: keyring.type,
+                hasMnemonic: !!keyring.mnemonic,
+                mnemonicLength: keyring.mnemonic ? keyring.mnemonic.length : 0,
+                hasAccounts: !!keyring.accounts,
+                accountsLength: keyring.accounts ? keyring.accounts.length : 0,
+                isAccountsArray: Array.isArray(keyring.accounts),
+                expectedFields: ['type', 'mnemonic', 'accounts'],
+                actualFields: Object.keys(keyring)
+            });
+        });
         const keyrings = [];
         for (const sKeyring of serializedKeyrings) {
-            if (sKeyring.type === 'HD') {
-                keyrings.push(await HDKeyring_1.HDKeyring.deserialize(sKeyring));
-            }
-            else if (sKeyring.type === 'Simple') {
-                keyrings.push(SimpleKeyring_1.SimpleKeyring.deserialize(sKeyring));
+            try {
+                if (sKeyring.type === 'HD') {
+                    keyrings.push(await HDKeyring_1.HDKeyring.deserialize(sKeyring));
+                }
+                else if (sKeyring.type === 'Simple') {
+                    keyrings.push(SimpleKeyring_1.SimpleKeyring.deserialize(sKeyring));
+                }
+                else if (sKeyring.type === 'Solana') {
+                    keyrings.push(await SolanaKeyring_1.SolanaKeyring.deserialize(sKeyring));
+                }
+                else {
+                    console.error('[VAULT_LOAD] FAILED HERE: Unknown keyring type');
+                    console.error('[VAULT_LOAD] FAILED DATA:', {
+                        keyringType: sKeyring.type,
+                        keyringData: sKeyring
+                    });
+                    throw new Error(`Unknown keyring type: ${sKeyring.type}`);
+                }
             }
-            else if (sKeyring.type === 'Solana') {
-                keyrings.push(await SolanaKeyring_1.SolanaKeyring.deserialize(sKeyring));
+            catch (error) {
+                console.error('[VAULT_LOAD] FAILED HERE: Keyring deserialize failed');
+                console.error('[VAULT_LOAD] FAILED DATA:', {
+                    keyringType: sKeyring.type,
+                    keyringData: sKeyring,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                // ADD LOG HERE: Analyze keyring data issues
+                console.error('[VAULT_LOAD] KEYRING DATA ANALYSIS:', {
+                    keyringType: sKeyring.type,
+                    hasType: !!sKeyring.type,
+                    hasMnemonic: !!sKeyring.mnemonic,
+                    hasAccounts: !!sKeyring.accounts,
+                    mnemonicType: typeof sKeyring.mnemonic,
+                    accountsType: typeof sKeyring.accounts,
+                    isAccountsArray: Array.isArray(sKeyring.accounts),
+                    expectedFields: sKeyring.type === 'HD' ? ['type', 'mnemonic', 'accounts'] : ['type', 'privateKey'],
+                    actualFields: Object.keys(sKeyring),
+                    missingFields: sKeyring.type === 'HD'
+                        ? ['type', 'mnemonic', 'accounts'].filter(field => !sKeyring[field])
+                        : ['type', 'privateKey'].filter(field => !sKeyring[field])
+                });
+                throw error;
             }
         }
         const vault = new Vault(keyrings, config);
@@ -291,9 +468,51 @@ class Vault {
      * @throws Error if encryption fails
      */
     async encrypt(password) {
+        // ADD LOG HERE: Before serialize
+        console.log('[VAULT_ENCRYPT] Before serialize:', {
+            keyringCount: this.keyrings.length,
+            keyringTypes: this.keyrings.map(k => k.type)
+        });
         const serializedKeyrings = this.keyrings.map(k => k.serialize());
-        const jsonString = JSON.stringify(serializedKeyrings);
-        return EncryptionService_1.EncryptionService.encrypt(jsonString, password);
+        // ADD LOG HERE: After serialize
+        console.log('[VAULT_ENCRYPT] Serialized keyrings:', {
+            serializedCount: serializedKeyrings.length,
+            serializedTypes: serializedKeyrings.map(k => k.type)
+        });
+        let jsonString;
+        try {
+            jsonString = JSON.stringify(serializedKeyrings);
+        }
+        catch (error) {
+            console.error('[VAULT_ENCRYPT] FAILED HERE: JSON stringify failed');
+            console.error('[VAULT_ENCRYPT] FAILED DATA:', {
+                serializedKeyrings: serializedKeyrings,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+        // ADD LOG HERE: JSON string
+        console.log('[VAULT_ENCRYPT] JSON string:', {
+            jsonString: jsonString,
+            jsonStringLength: jsonString.length,
+            isJsonValid: (() => {
+                try {
+                    JSON.parse(jsonString);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            })()
+        });
+        // ADD LOG HERE: After encrypt
+        const result = await EncryptionService_1.EncryptionService.encrypt(jsonString, password);
+        console.log('[VAULT_ENCRYPT] Encrypted result:', {
+            encryptedDataLength: result.encryptedData.length,
+            ivLength: result.iv.length,
+            saltLength: result.salt.length
+        });
+        return result;
     }
     /**
      * Retrieves the private key for a specific address from the appropriate keyring.

package/dist/config/constants.js

@@ -67,7 +67,7 @@ function getPBKDF2Iterations() {
     // }
     // React Native environment - use production values by default for security
     // Mobile apps should be considered production by default
-    return 4000;
+    return 6000;
 }
 /**
  * Network configuration constants

package/dist/crypto/EncryptionService.js

@@ -73,6 +73,16 @@ class EncryptionService {
      * @throws Error if encryption fails
      */
     static async encrypt(data, password) {
+        // ADD LOG HERE: Input parameters
+        console.log('[ENCRYPTION_ENCRYPT] Input:', {
+            data: data,
+            dataLength: data.length,
+            password: password,
+            passwordLength: password.length
+        });
+        // ADD LOG HERE: PBKDF2 iterations
+        const iterations = (0, constants_1.getPBKDF2Iterations)();
+        console.log('[ENCRYPTION_ENCRYPT] PBKDF2 iterations:', iterations);
         const salt = CryptoJS.lib.WordArray.random(SALT_LENGTH);
         const iv = CryptoJS.lib.WordArray.random(IV_LENGTH);
         const key = CryptoJS.PBKDF2(password, salt, {
@@ -85,11 +95,18 @@ class EncryptionService {
             mode: CryptoJS.mode.CBC,
             padding: CryptoJS.pad.Pkcs7,
         });
-        return {
+        const result = {
             encryptedData: encrypted.toString(),
             iv: CryptoJS.enc.Base64.stringify(iv),
             salt: CryptoJS.enc.Base64.stringify(salt),
         };
+        // ADD LOG HERE: Output
+        console.log('[ENCRYPTION_ENCRYPT] Output:', {
+            encryptedDataLength: result.encryptedData.length,
+            ivLength: result.iv.length,
+            saltLength: result.salt.length
+        });
+        return result;
     }
     /**
      * Decrypts data that was encrypted using the encrypt method.
@@ -99,6 +116,20 @@ class EncryptionService {
      * @throws Error if decryption fails due to incorrect password or corrupted data
      */
     static async decrypt(encryptedData, password) {
+        // ADD LOG HERE: Input parameters
+        console.log('[ENCRYPTION_DECRYPT] Input:', {
+            encryptedData: encryptedData.encryptedData,
+            encryptedDataLength: encryptedData.encryptedData.length,
+            iv: encryptedData.iv,
+            ivLength: encryptedData.iv.length,
+            salt: encryptedData.salt,
+            saltLength: encryptedData.salt.length,
+            password: password,
+            passwordLength: password.length
+        });
+        // ADD LOG HERE: PBKDF2 iterations
+        const iterations = (0, constants_1.getPBKDF2Iterations)();
+        console.log('[ENCRYPTION_DECRYPT] PBKDF2 iterations:', iterations);
         const salt = CryptoJS.enc.Base64.parse(encryptedData.salt);
         const iv = CryptoJS.enc.Base64.parse(encryptedData.iv);
         const key = CryptoJS.PBKDF2(password, salt, {
@@ -112,7 +143,37 @@ class EncryptionService {
             padding: CryptoJS.pad.Pkcs7,
         });
         const decryptedText = decrypted.toString(CryptoJS.enc.Utf8);
+        // ADD LOG HERE: Result
+        console.log('[ENCRYPTION_DECRYPT] Result:', {
+            decryptedText: decryptedText,
+            decryptedTextLength: decryptedText.length,
+            isEmpty: !decryptedText
+        });
+        // ADD LOG HERE: Error if any
         if (!decryptedText) {
+            console.error('[ENCRYPTION_DECRYPT] FAILED HERE: Decryption failed - empty result');
+            console.error('[ENCRYPTION_DECRYPT] FAILED DATA:', {
+                encryptedData: encryptedData.encryptedData,
+                iv: encryptedData.iv,
+                salt: encryptedData.salt,
+                password: password,
+                pbkdf2Iterations: iterations
+            });
+            // ADD LOG HERE: Analyze encryption parameters
+            console.error('[ENCRYPTION_DECRYPT] ENCRYPTION ANALYSIS:', {
+                encryptedDataLength: encryptedData.encryptedData.length,
+                ivLength: encryptedData.iv.length,
+                saltLength: encryptedData.salt.length,
+                passwordLength: password.length,
+                encryptedDataIsBase64: /^[A-Za-z0-9+/]*={0,2}$/.test(encryptedData.encryptedData),
+                ivIsBase64: /^[A-Za-z0-9+/]*={0,2}$/.test(encryptedData.iv),
+                saltIsBase64: /^[A-Za-z0-9+/]*={0,2}$/.test(encryptedData.salt),
+                passwordIsString: typeof password === 'string',
+                expectedIvLength: 16,
+                expectedSaltLength: 24,
+                ivLengthCorrect: encryptedData.iv.length === 16,
+                saltLengthCorrect: encryptedData.salt.length === 24
+            });
             throw new Error("Decryption failed. Invalid password or corrupted data.");
         }
         return decryptedText;

package/dist/keyrings/HDKeyring.js

@@ -101,11 +101,27 @@ class HDKeyring {
      * @returns An object containing the keyring type, mnemonic, and account addresses
      */
     serialize() {
-        return {
+        // ADD LOG HERE: Before serialize
+        console.log('[HDKEYRING_SERIALIZE] Input:', {
+            mnemonic: this.mnemonic,
+            accounts: this.accounts,
+            accountsCount: this.accounts.length,
+            hasMnemonic: !!this.mnemonic
+        });
+        const result = {
             type: this.type,
             mnemonic: this.mnemonic,
             accounts: this.accounts
         };
+        // ADD LOG HERE: After serialize
+        console.log('[HDKEYRING_SERIALIZE] Output:', {
+            type: result.type,
+            mnemonic: result.mnemonic,
+            accounts: result.accounts,
+            hasMnemonic: !!result.mnemonic,
+            accountsCount: result.accounts.length
+        });
+        return result;
     }
     /**
      * Deserializes data into an HDKeyring instance.
@@ -114,7 +130,53 @@ class HDKeyring {
      * @throws Error if the data is invalid or missing required fields
      */
     static async deserialize(data) {
-        if (data.type !== 'HD' || !data.mnemonic) {
+        // ADD LOG HERE: Input data
+        console.log('[HDKEYRING_DESERIALIZE] Input:', {
+            type: data.type,
+            mnemonic: data.mnemonic,
+            accounts: data.accounts,
+            hasMnemonic: !!data.mnemonic,
+            hasAccounts: !!data.accounts,
+            accountsCount: data.accounts ? data.accounts.length : 0
+        });
+        if (data.type !== 'HD') {
+            console.error('[HDKEYRING_DESERIALIZE] FAILED HERE: Wrong keyring type');
+            console.error('[HDKEYRING_DESERIALIZE] FAILED DATA:', {
+                expectedType: 'HD',
+                actualType: data.type,
+                data: data
+            });
+            // ADD LOG HERE: Analyze type mismatch
+            console.error('[HDKEYRING_DESERIALIZE] TYPE ANALYSIS:', {
+                expectedType: 'HD',
+                actualType: data.type,
+                typeIsString: typeof data.type === 'string',
+                typeIsNull: data.type === null,
+                typeIsUndefined: data.type === undefined,
+                typeLength: data.type ? data.type.length : 0,
+                availableTypes: ['HD', 'Simple', 'Solana'],
+                isKnownType: ['HD', 'Simple', 'Solana'].includes(data.type)
+            });
+            throw new Error('Invalid data for HDKeyring deserialization.');
+        }
+        if (!data.mnemonic) {
+            console.error('[HDKEYRING_DESERIALIZE] FAILED HERE: Missing mnemonic');
+            console.error('[HDKEYRING_DESERIALIZE] FAILED DATA:', {
+                data: data,
+                hasMnemonic: !!data.mnemonic
+            });
+            // ADD LOG HERE: Analyze mnemonic issues
+            console.error('[HDKEYRING_DESERIALIZE] MNEMONIC ANALYSIS:', {
+                hasMnemonic: !!data.mnemonic,
+                mnemonicType: typeof data.mnemonic,
+                mnemonicIsNull: data.mnemonic === null,
+                mnemonicIsUndefined: data.mnemonic === undefined,
+                mnemonicIsEmpty: data.mnemonic === '',
+                mnemonicLength: data.mnemonic ? data.mnemonic.length : 0,
+                expectedMnemonicLength: '12 words = ~132 chars, 24 words = ~264 chars',
+                availableFields: Object.keys(data),
+                missingFields: ['type', 'mnemonic', 'accounts'].filter(field => !data[field])
+            });
             throw new Error('Invalid data for HDKeyring deserialization.');
         }
         const keyring = new HDKeyring(data.mnemonic);
@@ -134,6 +196,12 @@ class HDKeyring {
         else {
             await keyring.initialize();
         }
+        // ADD LOG HERE: After deserialize
+        console.log('[HDKEYRING_DESERIALIZE] Output:', {
+            mnemonic: keyring.mnemonic,
+            accounts: keyring.accounts,
+            accountsCount: keyring.accounts.length
+        });
         return keyring;
     }
     /**

package/dist/keyrings/SimpleKeyring.js

@@ -28,10 +28,25 @@ class SimpleKeyring {
      * @returns An object containing the keyring type and private key
      */
     serialize() {
-        return {
+        // ADD LOG HERE: Before serialize
+        console.log('[SIMPLEKEYRING_SERIALIZE] Input:', {
+            privateKey: this.privateKey,
+            hasPrivateKey: !!this.privateKey,
+            privateKeyLength: this.privateKey.length,
+            address: this.address
+        });
+        const result = {
             type: this.type,
             privateKey: this.privateKey,
         };
+        // ADD LOG HERE: After serialize
+        console.log('[SIMPLEKEYRING_SERIALIZE] Output:', {
+            type: result.type,
+            privateKey: result.privateKey,
+            hasPrivateKey: !!result.privateKey,
+            privateKeyLength: result.privateKey.length
+        });
+        return result;
     }
     /**
      * Deserializes a plain object back into a SimpleKeyring instance.
@@ -40,10 +55,38 @@ class SimpleKeyring {
      * @throws Error if the data is invalid or missing required fields
      */
     static deserialize(data) {
-        if (data.type !== 'Simple' || !data.privateKey) {
+        // ADD LOG HERE: Input data
+        console.log('[SIMPLEKEYRING_DESERIALIZE] Input:', {
+            type: data.type,
+            privateKey: data.privateKey,
+            hasPrivateKey: !!data.privateKey,
+            privateKeyLength: data.privateKey ? data.privateKey.length : 0
+        });
+        if (data.type !== 'Simple') {
+            console.error('[SIMPLEKEYRING_DESERIALIZE] FAILED HERE: Wrong keyring type');
+            console.error('[SIMPLEKEYRING_DESERIALIZE] FAILED DATA:', {
+                expectedType: 'Simple',
+                actualType: data.type,
+                data: data
+            });
+            throw new Error('Invalid data for SimpleKeyring deserialization.');
+        }
+        if (!data.privateKey) {
+            console.error('[SIMPLEKEYRING_DESERIALIZE] FAILED HERE: Missing private key');
+            console.error('[SIMPLEKEYRING_DESERIALIZE] FAILED DATA:', {
+                data: data,
+                hasPrivateKey: !!data.privateKey
+            });
             throw new Error('Invalid data for SimpleKeyring deserialization.');
         }
-        return new SimpleKeyring(data.privateKey);
+        const keyring = new SimpleKeyring(data.privateKey);
+        // ADD LOG HERE: After deserialize
+        console.log('[SIMPLEKEYRING_DESERIALIZE] Output:', {
+            privateKey: keyring.getPrivateKey(),
+            address: keyring.address,
+            hasPrivateKey: !!keyring.getPrivateKey()
+        });
+        return keyring;
     }
 }
 exports.SimpleKeyring = SimpleKeyring;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pwc-sdk-wallet",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "description": "A comprehensive wallet SDK for React Native (pwc), supporting multi-chain and multi-account features.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",