Fixing JSON-RPC serialization issues where Uint8Array gets converted to plain objects

Author: maycon-mello

packages/core/src/cloud-wallet.ts

@@ -283,7 +283,12 @@ interface DocumentQueue {
 export async function generateCloudWalletMasterKey(): Promise<{ mnemonic: string; masterKey: Uint8Array }> {
   const mnemonic = await utilCryptoService.mnemonicGenerate(MNEMONIC_WORD_COUNT);
 
-  const masterKey = await utilCryptoService.mnemonicToMiniSecret(mnemonic);
+  const masterKeyResult = await utilCryptoService.mnemonicToMiniSecret(mnemonic);
+
+  // Ensure masterKey is a proper Uint8Array (JSON-RPC serialization converts it to a plain object)
+  const masterKey = masterKeyResult instanceof Uint8Array
+    ? masterKeyResult
+    : new Uint8Array(Object.values(masterKeyResult));
 
   return {
     mnemonic,
@@ -292,35 +297,34 @@ export async function generateCloudWalletMasterKey(): Promise<{ mnemonic: string
 }
 
 export async function recoverCloudWalletMasterKey(mnemonic: string): Promise<Uint8Array> {
-  const masterKey = await utilCryptoService.mnemonicToMiniSecret(mnemonic);
+  const masterKeyResult = await utilCryptoService.mnemonicToMiniSecret(mnemonic);
 
-  return masterKey;
+  // Ensure masterKey is a proper Uint8Array (JSON-RPC serialization converts it to a plain object)
+  return masterKeyResult instanceof Uint8Array
+    ? masterKeyResult
+    : new Uint8Array(Object.values(masterKeyResult));
 }
 
 export async function initializeCloudWallet({
   dataStore,
   edvUrl,
   authKey,
   masterKey,
+  mnemonic,
 }: {
   dataStore?: DataStore;
   edvUrl: string;
   authKey: string;
-  masterKey: Uint8Array;
+  masterKey?: Uint8Array;
+  mnemonic?: string;
 }) {
-  const {
-    hmacKey,
-    agreementKey,
-    verificationKey,
-  } = await edvService.deriveKeys(masterKey);
-
-  await edvService.initialize({
-    hmacKey,
-    agreementKey,
-    verificationKey,
-    edvUrl,
-    authKey
-  });
+  if (mnemonic) {
+    await edvService.initializeFromMnemonic({ mnemonic, edvUrl, authKey });
+  } else if (masterKey) {
+    await edvService.initializeFromMasterKey({ masterKey, edvUrl, authKey });
+  } else {
+    throw new Error('Either masterKey or mnemonic is required');
+  }
 
   const documentQueues = new Map<string, DocumentQueue>();
   const activeOperations = new Set<Promise<any>>();
@@ -498,18 +502,24 @@ export async function initializeCloudWallet({
   }
 
   async function pullDocuments() {
+    logger.debug('Pulling documents from EDV');
     const allDocs = await edvService.find({});
 
+    logger.debug(`Documents found in EDV: ${allDocs.documents.length}`);
+
     for (const doc of allDocs.documents) {
       const edvDoc = doc.content;
       const walletDoc = await dataStore.documents.getDocumentById(edvDoc.id);
 
       if (!walletDoc) {
-        const result = await dataStore.documents.addDocument(edvDoc, {
+        logger.debug(`Document ${edvDoc.id} not found in data store, adding to data store`);
+        await dataStore.documents.addDocument(edvDoc, {
           stopPropagation: true,
         });
       }
     }
+
+    return allDocs;
   }
 
   async function clearEdvDocuments() {

packages/wasm/src/services/edv/service-rpc.js

@@ -11,12 +11,20 @@ export class EDVServiceRpc extends RpcService {
     return this.call('initialize', params);
   }
 
+  initializeFromMnemonic(params: { mnemonic: string; edvUrl: string; authKey: string }) {
+    return this.call('initializeFromMnemonic', params);
+  }
+
+  initializeFromMasterKey(params: { masterKey: any; edvUrl: string; authKey: string }) {
+    return this.call('initializeFromMasterKey', params);
+  }
+
   generateKeys() {
     return this.call('generateKeys');
   }
 
-  deriveKeys() {
-    return this.call('deriveKeys');
+  deriveKeys(masterKey) {
+    return this.call('deriveKeys', masterKey);
   }
 
   getController() {

packages/wasm/src/services/edv/service.ts

@@ -19,6 +19,7 @@ import {didService} from '@docknetwork/wallet-sdk-wasm/src/services/dids/service
 import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 import hkdf from 'futoin-hkdf';
 import crypto from '@docknetwork/universal-wallet/crypto';
+import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto/service';
 
 export const HKDF_LENGTH = 32;
 export const HKDF_HASH = 'SHA-256';
@@ -40,6 +41,8 @@ export class EDVService {
     EDVService.prototype.deriveKeys,
     EDVService.prototype.getController,
     EDVService.prototype.initialize,
+    EDVService.prototype.initializeFromMnemonic,
+    EDVService.prototype.initializeFromMasterKey,
     EDVService.prototype.find,
     EDVService.prototype.update,
     EDVService.prototype.insert,
@@ -138,6 +141,43 @@ export class EDVService {
     });
   }
 
+  async initializeFromMnemonic({
+    mnemonic,
+    edvUrl,
+    authKey,
+  }: {
+    mnemonic: string;
+    edvUrl: string;
+    authKey: string;
+  }) {
+    const masterKey = await utilCryptoService.mnemonicToMiniSecret(mnemonic);
+    return this.initializeFromMasterKey({ masterKey, edvUrl, authKey });
+  }
+
+  async initializeFromMasterKey({
+    masterKey,
+    edvUrl,
+    authKey,
+  }: {
+    masterKey: Uint8Array;
+    edvUrl: string;
+    authKey: string;
+  }) {
+    if (!(masterKey instanceof Uint8Array)) {
+      masterKey = new Uint8Array(Object.values(masterKey));
+    }
+
+    const { verificationKey, agreementKey, hmacKey } = await this.deriveKeys(masterKey);
+
+    return this.initialize({
+      hmacKey,
+      agreementKey,
+      verificationKey,
+      edvUrl,
+      authKey,
+    });
+  }
+
   /**
    * Generates new cryptographic keys for EDV operations
    * @returns {Promise<Object>} Generated keys
@@ -181,6 +221,10 @@ export class EDVService {
    * const keys = await edvService.deriveKeys(masterKey);
    */
   async deriveKeys(masterKey: Uint8Array) {
+    // Ensure masterKey is a proper Uint8Array (JSON-RPC serialization converts it to a plain object)
+    if (!(masterKey instanceof Uint8Array)) {
+      masterKey = new Uint8Array(Object.values(masterKey));
+    }
     const {keyPair: pair} = new Ed25519Keypair(masterKey, 'seed');
 
     const keyPair = await didService.deriveKeyDoc({ pair });
@@ -330,8 +374,12 @@ export class EDVService {
     encryptionKey: Buffer,
     iv: Buffer
   ): Promise<Uint8Array> {
-    const keyData = new Uint8Array(encryptionKey);
-    const ivData = new Uint8Array(iv);
+    // Ensure typed arrays survive JSON-RPC serialization
+    if (!(masterKey instanceof Uint8Array)) {
+      masterKey = new Uint8Array(Object.values(masterKey));
+    }
+    const keyData = new Uint8Array(Object.values(encryptionKey));
+    const ivData = new Uint8Array(Object.values(iv));
 
     const key = await crypto.subtle.importKey(
       'raw',
@@ -366,8 +414,12 @@ export class EDVService {
     iv: Buffer
   ): Promise<Uint8Array> {
     try {
-      const keyData = new Uint8Array(decryptionKey);
-      const ivData = new Uint8Array(iv);
+      // Ensure typed arrays survive JSON-RPC serialization
+      if (!(encryptedKey instanceof Uint8Array)) {
+        encryptedKey = new Uint8Array(Object.values(encryptedKey));
+      }
+      const keyData = new Uint8Array(Object.values(decryptionKey));
+      const ivData = new Uint8Array(Object.values(iv));
 
       const key = await crypto.subtle.importKey(
         'raw',