feat!: wallet manager now takes an WalletManagerActivateProps object rather than just a wallet id

BREAKING CHANGES:

Author: AngelCastilloB

package.json

@@ -88,5 +88,8 @@
     "typedoc-plugin-missing-exports": "^1.0.0",
     "typescript": "^4.7.4"
   },
-  "packageManager": "[email protected]"
+  "packageManager": "[email protected]",
+  "dependencies": {
+    "chromedriver": "^120.0.0"
+  }
 }

packages/e2e/src/factories.ts

@@ -30,6 +30,7 @@ import {
   CommunicationType,
   InMemoryKeyAgent,
   KeyAgentDependencies,
+  Witnesser,
   util
 } from '@cardano-sdk/key-management';
 import {
@@ -282,6 +283,7 @@ export type GetWalletProps = {
   stores?: storage.WalletStores;
   customKeyParams?: KeyAgentFactoryProps;
   keyAgent?: AsyncKeyAgent;
+  witnesser?: Witnesser;
 };
 
 /** Delays initializing tx when nearing the epoch boundary. Relies on system clock being accurate. */
@@ -307,7 +309,7 @@ const patchInitializeTxToRespectEpochBoundary = <T extends ObservableWallet>(
  * @returns an object containing the wallet and providers passed to it
  */
 export const getWallet = async (props: GetWalletProps) => {
-  const { env, idx, logger, name, polling, stores, customKeyParams, keyAgent } = props;
+  const { env, idx, logger, name, polling, stores, customKeyParams, keyAgent, witnesser } = props;
   const providers = {
     addressDiscovery: await addressDiscoveryFactory.create(
       env.ADDRESS_DISCOVERY,
@@ -365,7 +367,7 @@ export const getWallet = async (props: GetWalletProps) => {
       bip32Account,
       logger,
       stores,
-      witnesser: util.createBip32Ed25519Witnesser(asyncKeyAgent)
+      witnesser: witnesser || util.createBip32Ed25519Witnesser(asyncKeyAgent)
     }
   );
 

packages/e2e/test/web-extension/extension/background/walletManager.ts

@@ -3,22 +3,25 @@ import {
   WalletFactory,
   WalletManagerActivateProps,
   WalletManagerWorker,
+  WalletRepository,
   exposeApi,
+  repositoryChannel,
   walletManagerChannel,
-  walletManagerProperties
+  walletManagerProperties,
+  walletRepositoryProperties
 } from '@cardano-sdk/web-extension';
 
-import { AsyncKeyAgent } from '@cardano-sdk/key-management';
 import { storage as WebExtensionStorage, runtime } from 'webextension-polyfill';
-import { env, logger } from '../util';
+import { Witnesser } from '@cardano-sdk/key-management';
+import { env, logger, Metadata } from "../util";
 import { from, merge, of } from 'rxjs';
 import { getWallet } from '../../../../src';
 import { storage } from '@cardano-sdk/wallet';
 import { toEmpty } from '@cardano-sdk/util-rxjs';
 import { walletName } from '../const';
 
 export interface WalletFactoryDependencies {
-  keyAgent: AsyncKeyAgent;
+  witnesser: Witnesser;
   stores: storage.WalletStores;
 }
 
@@ -28,30 +31,40 @@ export interface WalletFactoryDependencies {
  * Please check its documentation for examples.
  */
 const walletFactory: WalletFactory = {
-  create: async (props: WalletManagerActivateProps, { keyAgent, stores }: WalletFactoryDependencies) =>
+  create: async (props: WalletManagerActivateProps, { witnesser, stores }: WalletFactoryDependencies) =>
     (
       await getWallet({
         env,
-        keyAgent,
         logger,
         name: props.observableWalletName,
-        stores
+        stores,
+        witnesser
       })
     ).wallet
 };
 
 const storesFactory: StoresFactory = {
-  create: ({ walletId }) => storage.createPouchDbWalletStores(walletId, { logger })
+  create: ({ name }) => storage.createPouchDbWalletStores(name, { logger })
 };
 
-export const wallet$ = (() => {
-  const walletManager = new WalletManagerWorker(
-    { walletName },
-    { logger, managerStorage: WebExtensionStorage.local, runtime, storesFactory, walletFactory }
-  );
-  exposeApi(
-    { api$: of(walletManager), baseChannel: walletManagerChannel(walletName), properties: walletManagerProperties },
-    { logger, runtime }
-  );
-  return merge(walletManager.activeWallet$, from(walletManager.initialize()).pipe(toEmpty));
-})();
+const walletRepository = new WalletRepository<Metadata>({
+  logger,
+  store: new storage.InMemoryCollectionStore()
+});
+
+const walletManager = new WalletManagerWorker<Metadata>(
+  { walletName },
+  { logger, managerStorage: WebExtensionStorage.local, runtime, storesFactory, walletFactory, walletRepository }
+);
+
+exposeApi(
+  { api$: of(walletRepository), baseChannel: repositoryChannel(walletName), properties: walletRepositoryProperties },
+  { logger, runtime }
+);
+
+exposeApi(
+  { api$: of(walletManager), baseChannel: walletManagerChannel(walletName), properties: walletManagerProperties },
+  { logger, runtime }
+);
+
+export const wallet$ = (() => merge(walletManager.activeWallet$, from(walletManager.initialize()).pipe(toEmpty)))();

packages/e2e/test/web-extension/extension/manifest.json

@@ -9,7 +9,7 @@
     "unlimitedStorage"
   ],
   "content_security_policy": {
-    "extension_pages": "default-src 'self' http://localhost:3000; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; connect-src data: http://localhost:8080 https://backend.live-preprod.eks.lw.iog.io https://api.coingecko.com http://167.235.156.245:4000 http://localhost:3000 ws://localhost:3000 wss://localhost:3000 http://localhost:4000 ws://localhost:4000 wss://localhost:4000 http://testnet-dev-backend.dev.lw.iog.io:80 http://localhost:4567 https://testnet-dev-backend.dev.lw.iog.io:443 https://preprod-api.v2.prod.lw.iog.io; style-src * 'unsafe-inline'; img-src * data:; font-src https://fonts.gstatic.com;"
+    "extension_pages": "default-src 'self' http://localhost:3000; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; connect-src data: http://localhost:8080 https://backend.live-preprod.eks.lw.iog.io https://api.coingecko.com http://167.235.156.245:4000 http://localhost:3000 ws://localhost:3000 wss://localhost:3000 http://localhost:4011 ws://localhost:4011 wss://localhost:4011 http://localhost:4000 ws://localhost:4000 wss://localhost:4000 http://testnet-dev-backend.dev.lw.iog.io:80 http://localhost:4567 https://testnet-dev-backend.dev.lw.iog.io:443 https://preprod-api.v2.prod.lw.iog.io; style-src * 'unsafe-inline'; img-src * data:; font-src https://fonts.gstatic.com;"
   },
   "web_accessible_resources": [
     {

packages/e2e/test/web-extension/extension/ui.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-use-before-define */
 import {
   BackgroundServices,
+  Metadata,
   UserPromptService,
   adaPriceProperties,
   disconnectPortTestObjProperties,
@@ -9,10 +10,14 @@ import {
 } from './util';
 import {
   RemoteApiPropertyType,
+  SignerManager,
   WalletManagerUi,
+  WalletType,
   consumeRemoteApi,
   consumeSupplyDistributionTracker,
-  exposeApi
+  createKeyAgentFactory,
+  exposeApi,
+  exposeSignerManagerApi
 } from '@cardano-sdk/web-extension';
 import {
   adaPriceServiceChannel,
@@ -21,12 +26,20 @@ import {
   userPromptServiceChannel,
   walletName
 } from './const';
-import { keyManagementFactory } from '../../../src';
 
+import * as Crypto from '@cardano-sdk/crypto';
+import { Buffer } from 'buffer';
 import { Cardano } from '@cardano-sdk/core';
+import {
+  CommunicationType,
+  InMemoryKeyAgent,
+  SerializableInMemoryKeyAgentData,
+  emip3encrypt,
+  util
+} from '@cardano-sdk/key-management';
 import { HexBlob } from '@cardano-sdk/util';
 import { SodiumBip32Ed25519 } from '@cardano-sdk/crypto';
-import { combineLatest, firstValueFrom, of } from 'rxjs';
+import { combineLatest, firstValueFrom, merge, of } from 'rxjs';
 import { runtime } from 'webextension-polyfill';
 
 const delegationConfig = {
@@ -198,7 +211,48 @@ const cleanupMultidelegationInfo = (multiDelegationDiv: Element) => {
   }
 };
 
-const walletManager = new WalletManagerUi({ walletName }, { logger, runtime });
+const signerManager = new SignerManager(
+  {
+    hwOptions: {
+      communicationType: CommunicationType.Web,
+      manifest: {
+        appUrl: 'https://web-extension.app',
+        email: '[email protected]'
+      }
+    }
+  },
+  {
+    keyAgentFactory: createKeyAgentFactory({
+      bip32Ed25519: new Crypto.SodiumBip32Ed25519(),
+      logger
+    })
+  }
+);
+
+const passphraseByteArray = Uint8Array.from(
+  env.KEY_MANAGEMENT_PARAMS.passphrase.split('').map((letter) => letter.charCodeAt(0))
+);
+merge(signerManager.signDataRequest$, signerManager.transactionWitnessRequest$).subscribe((req) => {
+  logger.info('Sign request', req);
+  if (req.walletType === WalletType.InMemory) {
+    req.sign(new Uint8Array(passphraseByteArray));
+  } else {
+    req.sign();
+  }
+  logger.info('Signed', req);
+});
+
+// Expose signer manager.
+exposeSignerManagerApi(
+  {
+    signerManager
+  },
+  { logger, runtime }
+);
+
+// TODO: toSerializableObj does not support serializing empty obj {}
+const walletManager = new WalletManagerUi<Metadata>({ walletName }, { logger, runtime });
+
 // Wallet object does not change when wallets are activated/deactivated.
 // Instead, it's observable properties emit from the currently active wallet.
 const wallet = walletManager.wallet;
@@ -220,30 +274,72 @@ wallet.delegation.distribution$.subscribe((delegationDistrib) => {
   }
 });
 
-const createWallet = async (accountIndex: number) => {
-  clearWalletValues();
-
-  const keyAgent = await (
-    await keyManagementFactory.create(
-      env.KEY_MANAGEMENT_PROVIDER,
+const createWalletIfNotExistsAndActivate = async (accountIndex: number) => {
+  const wallets = await firstValueFrom(walletManager.repository.wallets$);
+  let walletId = wallets.find(
+    (w) => w.type !== WalletType.Script && w.accounts.some((a) => a.accountIndex === accountIndex)
+  )?.walletId;
+  if (!walletId) {
+    logger.log('creating wallet');
+    clearWalletValues();
+    const bip32Ed25519 = new SodiumBip32Ed25519();
+    const mnemonicWords = env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' ');
+    const passphrase = new Uint8Array(passphraseByteArray);
+    const keyAgent = await InMemoryKeyAgent.fromBip39MnemonicWords(
       {
-        ...env.KEY_MANAGEMENT_PARAMS,
-        accountIndex
+        accountIndex,
+        chainId: env.KEY_MANAGEMENT_PARAMS.chainId,
+        getPassphrase: async () => passphrase,
+        mnemonicWords
       },
-      logger
-    )
-  )({ bip32Ed25519: new SodiumBip32Ed25519(), logger });
+      { bip32Ed25519, logger }
+    );
+    const encryptedRootPrivateKey = (keyAgent.serializableData as SerializableInMemoryKeyAgentData)
+      .encryptedRootPrivateKeyBytes;
+
+    const entropy = Buffer.from(util.mnemonicWordsToEntropy(mnemonicWords), 'hex');
+    const encryptedEntropy = await emip3encrypt(entropy, passphraseByteArray);
+
+    logger.log('adding to repository wallet');
+    // Add wallet to the repository.
+    walletId = await walletManager.repository.addWallet({
+      encryptedSecrets: {
+        entropy: HexBlob.fromBytes(encryptedEntropy),
+        rootPrivateKeyBytes: HexBlob.fromBytes(new Uint8Array(encryptedRootPrivateKey))
+      },
+      extendedAccountPublicKey: keyAgent.serializableData.extendedAccountPublicKey,
+      type: WalletType.InMemory
+    });
+    await walletManager.repository.addAccount({
+      accountIndex,
+      metadata: { name: `Wallet #${accountIndex + 1}` },
+      walletId
+    });
 
-  await walletManager.destroy();
-  await walletManager.activate({ keyAgent, observableWalletName: getObservableWalletName(accountIndex) });
+    logger.log(`Wallet added: ${walletId}`);
+  } else {
+    logger.info(`Wallet with accountIndex ${accountIndex} already exists`);
+  }
+
+  // await walletManager.destroy();
+  await walletManager.activate({
+    accountIndex,
+    chainId: env.KEY_MANAGEMENT_PARAMS.chainId,
+    observableWalletName: getObservableWalletName(accountIndex),
+    walletId
+  });
 
   // Same wallet object will return different names, based on which wallet is active
   // Calling this method before any wallet is active, will resolve only once a wallet becomes active
   setName(await wallet.getName());
 };
 
-document.querySelector(selectors.btnActivateWallet1)!.addEventListener('click', async () => await createWallet(0));
-document.querySelector(selectors.btnActivateWallet2)!.addEventListener('click', async () => await createWallet(1));
+document
+  .querySelector(selectors.btnActivateWallet1)!
+  .addEventListener('click', async () => await createWalletIfNotExistsAndActivate(0));
+document
+  .querySelector(selectors.btnActivateWallet2)!
+  .addEventListener('click', async () => await createWalletIfNotExistsAndActivate(1));
 document.querySelector(selectors.deactivateWallet)!.addEventListener('click', async () => await deactivateWallet());
 document.querySelector(selectors.destroyWallet)!.addEventListener('click', async () => await destroyWallet());
 document.querySelector(selectors.btnDelegate)!.addEventListener('click', async () => {
@@ -253,7 +349,10 @@ document.querySelector(selectors.btnDelegate)!.addEventListener('click', async (
 });
 
 document.querySelector(selectors.btnSignAndBuildTx)!.addEventListener('click', async () => {
+  logger.info('Building transaction');
   const [{ address: ownAddress }] = await firstValueFrom(wallet.addresses$);
+  logger.info(`Address: ${ownAddress}`);
+
   const builtTx = wallet
     .createTxBuilder()
     .addOutput({
@@ -264,6 +363,7 @@ document.querySelector(selectors.btnSignAndBuildTx)!.addEventListener('click', a
   const { body } = await builtTx.inspect();
   logger.info('Built tx', body.outputs.length);
   const { tx: signedTx } = await builtTx.sign();
+  logger.error(signedTx);
   setSignature(signedTx.witness.signatures.values().next().value);
 });
 

packages/e2e/test/web-extension/extension/util.ts

@@ -35,3 +35,5 @@ export const disconnectPortTestObjProperties: RemoteApiProperties<DisconnectPort
 export const logger = console;
 
 export const env = getEnv(walletVariables);
+
+export type Metadata = { name: string };

packages/key-management/src/InMemoryKeyAgent.ts

@@ -161,6 +161,7 @@ export class InMemoryKeyAgent extends KeyAgentBase implements KeyAgent {
   async #decryptRootPrivateKey(noCache?: true) {
     const passphrase = await getPassphraseRethrowTypedError(() => this.#getPassphrase(noCache));
     let decryptedRootKeyBytes: Uint8Array;
+
     try {
       decryptedRootKeyBytes = await emip3decrypt(
         new Uint8Array((this.serializableData as SerializableInMemoryKeyAgentData).encryptedRootPrivateKeyBytes),

packages/key-management/src/types.ts

@@ -1,5 +1,5 @@
 import * as Crypto from '@cardano-sdk/crypto';
-import { Cardano } from '@cardano-sdk/core';
+import { Cardano, Serialization } from '@cardano-sdk/core';
 import { HexBlob, OpaqueString, Shutdown } from '@cardano-sdk/util';
 import { Logger } from 'ts-log';
 import type { Runtime } from 'webextension-polyfill';
@@ -222,12 +222,13 @@ export interface Witnesser {
   /**
    * Generates the witness data for a given transaction.
    *
-   * @param txInternals The transaction body along with its hash for which the witness data is to be generated.
+   * @param transaction The transaction along with its hash for which the witness data is to be generated.
+   * @param context The witness sign transaction context
    * @param options Optional additional parameters that may influence how the witness data is generated.
    * @returns A promise that resolves to the generated witness data for the transaction.
    */
   witness(
-    txInternals: Cardano.TxBodyWithHash,
+    transaction: Serialization.Transaction,
     context: SignTransactionContext,
     options?: WitnessOptions
   ): Promise<Cardano.Witness>;