@cardano-sdk/e2e 0.25.0 → 0.26.0

package/test/long-running/multisig-wallet/multisig-delegation-rewards.test.ts

@@ -0,0 +1,318 @@
+import * as Crypto from '@cardano-sdk/crypto';
+import { Cardano, EraSummary, StakePoolProvider, createSlotEpochCalc } from '@cardano-sdk/core';
+import { InMemoryKeyAgent, KeyRole } from '@cardano-sdk/key-management';
+import { MultiSigTx } from './MultiSigTx';
+import { MultiSigWallet } from './MultiSigWallet';
+import { Observable, filter, firstValueFrom, map, take } from 'rxjs';
+import { PersonalWallet } from '@cardano-sdk/wallet';
+import { TrackerSubject } from '@cardano-sdk/util-rxjs';
+import {
+  bip32Ed25519Factory,
+  createStandaloneKeyAgent,
+  getEnv,
+  getWallet,
+  waitForEpoch,
+  walletReady,
+  walletVariables
+} from '../../../src';
+import { isNotNil } from '@cardano-sdk/util';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv(walletVariables);
+
+// eslint-disable-next-line max-len
+const aliceMnemonics =
+  'decorate survey empower stairs pledge humble social leisure baby wrap grief exact monster rug dash kiss perfect select science light frame play swallow day';
+
+// eslint-disable-next-line max-len
+const bobMnemonics =
+  'salon zoo engage submit smile frost later decide wing sight chaos renew lizard rely canal coral scene hobby scare step bus leaf tobacco slice';
+
+// eslint-disable-next-line max-len
+const charlotteMnemonics =
+  'phrase raw learn suspect inmate powder combine apology regular hero gain chronic fruit ritual short screen goddess odor keen creek brand today kit machine';
+
+const DERIVATION_PATH = {
+  index: 0,
+  role: KeyRole.External
+};
+
+const getPoolIds = async (stakePoolProvider: StakePoolProvider, count: number) => {
+  const activePools = await stakePoolProvider.queryStakePools({
+    filters: { pledgeMet: true, status: [Cardano.StakePoolStatus.Active] },
+    pagination: { limit: count, startAt: 0 }
+  });
+  expect(activePools.totalResultCount).toBeGreaterThanOrEqual(count);
+  const poolIds = activePools.pageResults.map(({ id }) => id);
+  expect(poolIds.every((poolId) => poolId !== undefined)).toBeTruthy();
+  logger.info('Wallet funds will be staked to pools:', poolIds);
+  return poolIds;
+};
+
+const fundMultiSigWallet = async (sendingWallet: PersonalWallet, address: Cardano.PaymentAddress) => {
+  logger.info(`Funding multisig wallet with address: ${address}`);
+
+  const tAdaToSend = 5_000_000n;
+
+  const txBuilder = sendingWallet.createTxBuilder();
+  const txOut = await txBuilder.buildOutput().address(address).coin(tAdaToSend).build();
+  const { tx: signedTx } = await txBuilder.addOutput(txOut).build().sign();
+  await sendingWallet.submitTx(signedTx);
+};
+
+const getKeyAgent = async (mnemonics: string, faucetWallet: PersonalWallet, bip32Ed25519: Crypto.Bip32Ed25519) => {
+  const genesis = await firstValueFrom(faucetWallet.genesisParameters$);
+
+  const keyAgent = await createStandaloneKeyAgent(mnemonics.split(' '), genesis, bip32Ed25519);
+
+  const pubKey = await keyAgent.derivePublicKey(DERIVATION_PATH);
+
+  return { keyAgent, pubKey };
+};
+
+const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: PersonalWallet) => {
+  logger.info('Sending 100 txs to generate reward fees');
+
+  const tAdaToSend = 5_000_000n;
+  const [{ address: receivingAddress }] = await firstValueFrom(receivingWallet.addresses$);
+
+  for (let i = 0; i < 100; i++) {
+    const txBuilder = sendingWallet.createTxBuilder();
+    const txOut = await txBuilder.buildOutput().address(receivingAddress).coin(tAdaToSend).build();
+    const { tx: signedTx } = await txBuilder.addOutput(txOut).build().sign();
+    await sendingWallet.submitTx(signedTx);
+  }
+};
+
+const createMultiSignWallet = async (
+  keyAgent: InMemoryKeyAgent,
+  faucetWallet: PersonalWallet,
+  participants: Array<Crypto.Ed25519PublicKeyHex>
+) => {
+  const props = {
+    chainHistoryProvider: faucetWallet.chainHistoryProvider,
+    expectedSigners: participants,
+    inMemoryKeyAgent: keyAgent,
+    networkId: env.KEY_MANAGEMENT_PARAMS.chainId.networkId,
+    networkInfoProvider: faucetWallet.networkInfoProvider,
+    pollingInterval: 50,
+    rewardsProvider: faucetWallet.rewardsProvider,
+    txSubmitProvider: faucetWallet.txSubmitProvider,
+    utxoProvider: faucetWallet.utxoProvider
+  };
+
+  return await MultiSigWallet.createMultiSigWallet(props);
+};
+
+const getTxConfirmationEpoch = async (
+  history$: Observable<Cardano.HydratedTx[]>,
+  tx: Cardano.Tx<Cardano.TxBody>,
+  eraSummaries$: TrackerSubject<EraSummary[]>
+) => {
+  const txs = await firstValueFrom(history$.pipe(filter((_) => _.some(({ id }) => id === tx.id))));
+  const observedTx = txs.find(({ id }) => id === tx.id);
+  const slotEpochCalc = createSlotEpochCalc(await firstValueFrom(eraSummaries$));
+
+  return slotEpochCalc(observedTx!.blockHeader.slot);
+};
+
+describe('multi signature wallet', () => {
+  let faucetWallet: PersonalWallet;
+  let aliceKeyAgent: InMemoryKeyAgent;
+  let bobKeyAgent: InMemoryKeyAgent;
+  let charlotteKeyAgent: InMemoryKeyAgent;
+  let alicePubKey: Crypto.Ed25519PublicKeyHex;
+  let bobPubKey: Crypto.Ed25519PublicKeyHex;
+  let charlottePubKey: Crypto.Ed25519PublicKeyHex;
+  let faucetAddress: Cardano.PaymentAddress;
+  let aliceMultiSigWallet: MultiSigWallet;
+  let bobMultiSigWallet: MultiSigWallet;
+  let charlotteMultiSigWallet: MultiSigWallet;
+  let multiSigParticipants: Crypto.Ed25519PublicKeyHex[];
+
+  const initializeFaucet = async () => {
+    ({ wallet: faucetWallet } = await getWallet({
+      env,
+      logger,
+      name: 'Faucet Wallet',
+      polling: { interval: 50 }
+    }));
+
+    await walletReady(faucetWallet);
+  };
+
+  beforeAll(async () => {
+    await initializeFaucet();
+    const bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
+
+    ({ keyAgent: aliceKeyAgent, pubKey: alicePubKey } = await getKeyAgent(aliceMnemonics, faucetWallet, bip32Ed25519));
+    ({ keyAgent: bobKeyAgent, pubKey: bobPubKey } = await getKeyAgent(bobMnemonics, faucetWallet, bip32Ed25519));
+    ({ keyAgent: charlotteKeyAgent, pubKey: charlottePubKey } = await getKeyAgent(
+      charlotteMnemonics,
+      faucetWallet,
+      bip32Ed25519
+    ));
+
+    faucetAddress = (await firstValueFrom(faucetWallet.addresses$))[0].address;
+
+    multiSigParticipants = [alicePubKey, bobPubKey, charlottePubKey];
+
+    aliceMultiSigWallet = await createMultiSignWallet(aliceKeyAgent, faucetWallet, multiSigParticipants);
+    bobMultiSigWallet = await createMultiSignWallet(bobKeyAgent, faucetWallet, multiSigParticipants);
+    charlotteMultiSigWallet = await createMultiSignWallet(charlotteKeyAgent, faucetWallet, multiSigParticipants);
+  });
+
+  afterAll(() => {
+    faucetWallet?.shutdown();
+  });
+
+  it('can receive balance and can spend balance', async () => {
+    expect(aliceMultiSigWallet.getPaymentAddress()).toEqual(bobMultiSigWallet.getPaymentAddress());
+    expect(aliceMultiSigWallet.getPaymentAddress()).toEqual(charlotteMultiSigWallet.getPaymentAddress());
+
+    await fundMultiSigWallet(faucetWallet, bobMultiSigWallet.getPaymentAddress());
+
+    const multiSigWalletBalance = await firstValueFrom(
+      bobMultiSigWallet.getBalance().pipe(
+        map((value) => value.coins),
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletBalance).toBeGreaterThan(0n);
+
+    // Alice will initiate the transaction on her wallet.
+    let tx = await aliceMultiSigWallet.transferFunds(faucetAddress, { coins: 2_000_000n });
+
+    // Alice then signs the transaction and relay it to Bob.
+    tx = await aliceMultiSigWallet.sign(tx);
+    const aliceSerializedTx = tx.toCbor();
+
+    // .... Bob receives the transaction and signs it.
+    let bobTx = MultiSigTx.fromCbor(aliceSerializedTx);
+    bobTx = await bobMultiSigWallet.sign(bobTx);
+
+    // Bob can then check if there are any missing signatures. If there are, he can then
+    // check who is missing and send the transaction to them.
+    expect(bobTx.isFullySigned()).toBe(false);
+    expect(bobTx.getMissingSigners()).toEqual([charlottePubKey]);
+
+    const bobSerializedTx = bobTx.toCbor();
+
+    // .... Charlotte receives the transaction and signs it.
+    let charlotteTx = MultiSigTx.fromCbor(bobSerializedTx);
+    charlotteTx = await charlotteMultiSigWallet.sign(charlotteTx);
+
+    // Charlotte can then check if there are any missing signatures. And if all signatures
+    // are complete she can submit it to the network.
+    expect(charlotteTx.getMissingSigners()).toEqual([]);
+    expect(charlotteTx.isFullySigned()).toBe(true);
+    const txId = await charlotteMultiSigWallet.submit(charlotteTx);
+
+    // Search chain history to see if the transaction is there.
+    const txFoundInHistory = await firstValueFrom(
+      faucetWallet.transactions.history$.pipe(
+        map((txs) => txs.find((hTx) => hTx.id === txId)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(txFoundInHistory).toBeTruthy();
+  });
+
+  // eslint-disable-next-line max-statements
+  it('delegate to a pool and claim rewards', async () => {
+    expect(aliceMultiSigWallet.getRewardAccount()).toEqual(bobMultiSigWallet.getRewardAccount());
+    expect(aliceMultiSigWallet.getRewardAccount()).toEqual(charlotteMultiSigWallet.getRewardAccount());
+
+    await fundMultiSigWallet(faucetWallet, bobMultiSigWallet.getPaymentAddress());
+
+    const multiSigWalletBalance = await firstValueFrom(
+      bobMultiSigWallet.getBalance().pipe(
+        map((value) => value.coins),
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletBalance).toBeGreaterThan(0n);
+
+    const [poolId] = await getPoolIds(faucetWallet.stakePoolProvider, 1);
+
+    // Alice will initiate the delegation transaction on her wallet.
+    let tx = await aliceMultiSigWallet.delegate(poolId);
+    tx = await aliceMultiSigWallet.sign(tx);
+    tx = await bobMultiSigWallet.sign(tx);
+    tx = await charlotteMultiSigWallet.sign(tx);
+
+    const txId = await charlotteMultiSigWallet.submit(tx);
+
+    // Search chain history to see if the transaction is there.
+    const txFoundInHistory = await firstValueFrom(
+      charlotteMultiSigWallet.getTransactionHistory().pipe(
+        map((txs) => txs.find((hTx) => hTx.id === txId)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(txFoundInHistory).toBeTruthy();
+
+    // Delegation is completed. Now we wait for rewards to be available.
+    const delegationTxConfirmedAtEpoch = await getTxConfirmationEpoch(
+      charlotteMultiSigWallet.getTransactionHistory(),
+      tx.getTransaction(),
+      faucetWallet.eraSummaries$
+    );
+
+    logger.info(`Delegation tx confirmed at epoch #${delegationTxConfirmedAtEpoch}`);
+
+    await waitForEpoch(faucetWallet, delegationTxConfirmedAtEpoch + 2);
+    await generateTxs(faucetWallet, faucetWallet);
+    await waitForEpoch(faucetWallet, delegationTxConfirmedAtEpoch + 4);
+
+    // Check reward
+    const multiSigWalletRewardBalance = await firstValueFrom(
+      bobMultiSigWallet.getRewardAccountBalance().pipe(
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletRewardBalance).toBeGreaterThan(0n);
+
+    logger.info(`Generated rewards: ${multiSigWalletRewardBalance} tLovelace`);
+
+    tx = await aliceMultiSigWallet.transferFunds(faucetAddress, { coins: 2_000_000n });
+    expect(tx.getTransaction().body.withdrawals?.length).toBeGreaterThan(0);
+
+    tx = await aliceMultiSigWallet.sign(tx);
+    tx = await bobMultiSigWallet.sign(tx);
+    tx = await charlotteMultiSigWallet.sign(tx);
+
+    const spendRewardsTx = await charlotteMultiSigWallet.submit(tx);
+
+    // Search chain history to see if the transaction is there.
+    const spendRewardsTxFoundInHistory = await firstValueFrom(
+      faucetWallet.transactions.history$.pipe(
+        map((txs) => txs.find((hTx) => hTx.id === spendRewardsTx)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(spendRewardsTxFoundInHistory).toBeTruthy();
+
+    // Check reward
+    const finalRewardBalance = await firstValueFrom(
+      bobMultiSigWallet.getRewardAccountBalance().pipe(
+        filter((value) => value === 0n),
+        take(1)
+      )
+    );
+
+    expect(finalRewardBalance).toEqual(0n);
+  });
+});

package/test/projection/offline-fork.test.ts

@@ -28,7 +28,7 @@ import { ReconnectionConfig } from '@cardano-sdk/util-rxjs';
 import { createDatabase } from 'typeorm-extension';
 import { getEnv } from '../../src';
 
-const dataWithStakeKeyDeregistration = chainSyncData(ChainSyncDataSet.WithStakeKeyDeregistration);
+const dataWithStakeDeregistration = chainSyncData(ChainSyncDataSet.WithStakeKeyDeregistration);
 
 const ogmiosConnectionConfig = ((): ConnectionConfig => {
   const { OGMIOS_URL } = getEnv(['OGMIOS_URL']);
@@ -66,22 +66,22 @@ const createForkProjectionSource = (
   // eslint-disable-next-line sort-keys-fix/sort-keys-fix
   findIntersect: (points) => {
     const intersectionPoint = points[0] as Point;
-    const someEventsWithStakeKeyRegistration = dataWithStakeKeyDeregistration.allEvents
+    const someEventsWithStakeRegistration = dataWithStakeDeregistration.allEvents
       .filter(
         (evt): evt is Omit<ChainSyncRollForward, 'requestNext'> =>
           evt.eventType === ChainSyncEventType.RollForward &&
           evt.block.body.some((tx) =>
-            tx.body.certificates?.some((cert) => cert.__typename === Cardano.CertificateType.StakeKeyRegistration)
+            tx.body.certificates?.some((cert) => cert.__typename === Cardano.CertificateType.StakeRegistration)
           )
       )
       .slice(0, 2);
     return of({
       chainSync$: new Observable<ChainSyncEvent>((subscriber) => {
-        const events = [...someEventsWithStakeKeyRegistration];
+        const events = [...someEventsWithStakeRegistration];
         const next = () => {
           const nextEvt = events.shift();
           if (nextEvt) {
-            const blockOffset = someEventsWithStakeKeyRegistration.length - events.length;
+            const blockOffset = someEventsWithStakeRegistration.length - events.length;
             const slot = Cardano.Slot(intersectionPoint.slot + blockOffset * 20);
             const blockNo = Cardano.BlockNo(lastEvt.block.header.blockNo + blockOffset);
             subscriber.next({
@@ -104,7 +104,7 @@ const createForkProjectionSource = (
       }),
       intersection: {
         point: intersectionPoint,
-        tip: someEventsWithStakeKeyRegistration[someEventsWithStakeKeyRegistration.length - 1].tip
+        tip: someEventsWithStakeRegistration[someEventsWithStakeRegistration.length - 1].tip
       }
     });
   },

package/test/projection/single-tenant-utxo.test.ts

@@ -75,7 +75,7 @@ const countUniqueOutputAddresses = (queryRunner: QueryRunner) =>
     .getRawMany()
     .then((results) => results.length);
 
-describe('single-tenant utxo projection', () => {
+describe.skip('single-tenant utxo projection', () => {
   let cardanoNode: ObservableCardanoNode;
   let connection$: Observable<Postgres.TypeormConnection>;
   let buffer: Postgres.TypeormStabilityWindowBuffer;

package/test/providers/StakePoolProvider.test.ts

@@ -388,6 +388,7 @@ describe('StakePoolProvider', () => {
 
           filters = { identifier: { values: poolsId.map((id) => ({ id })) } };
         });
+
         it('ascending sort by live saturation', async () => {
           if (poolsId.length < 2)
             return console.log(
@@ -403,6 +404,7 @@ describe('StakePoolProvider', () => {
               .map((p) => p.metrics?.saturation)
           );
         });
+
         it('descending sort by live saturation', async () => {
           if (poolsId.length < 2)
             return console.log(
@@ -420,42 +422,45 @@ describe('StakePoolProvider', () => {
         });
       });
 
-      describe('sort by apy', () => {
+      describe.each(['lastRos', 'ros'] as const)('sort by %s', (field) => {
         let filters: QueryStakePoolsArgs['filters'] = {};
         const poolsId: Cardano.PoolId[] = [];
 
         beforeAll(() => {
-          for (const pool of pools) {
-            if (poolsId.length < 20 && pool.metrics?.apy !== undefined && pool.metrics?.apy > 0) {
+          for (const pool of pools)
+            if (poolsId.length < 20 && pool.metrics?.[field] !== undefined && pool.metrics?.[field] > 0)
               poolsId.push(pool.id);
-            }
-          }
+
           filters = { identifier: { values: poolsId.map((id) => ({ id })) } };
         });
-        it('ascending sort by apy', async () => {
+
+        it(`ascending sort by ${field}`, async () => {
           if (poolsId.length < 2)
-            return console.log("test 'ascending sort by apy' can't run because no suitable pools were found");
-          const { pageResults, totalResultCount } = await query(filters, { field: 'apy', order: 'asc' });
+            return console.log(`test 'ascending sort by ${field}' can't run because no suitable pools were found`);
+
+          const { pageResults, totalResultCount } = await query(filters, { field, order: 'asc' });
 
           expect(totalResultCount).toBe(poolsId.length);
-          expect(pageResults.map((p) => p.metrics?.apy)).toStrictEqual(
+          expect(pageResults.map((p) => p.metrics?.[field])).toStrictEqual(
             pools
               .filter(({ id }) => poolsId.includes(id))
-              .sort((a, b) => (a.metrics!.apy! < b.metrics!.apy! ? -1 : 1))
-              .map((p) => p.metrics?.apy)
+              .sort((a, b) => (a.metrics![field]! < b.metrics![field]! ? -1 : 1))
+              .map((p) => p.metrics![field])
           );
         });
-        it('descending sort by apy', async () => {
+
+        it(`descending sort by ${field}`, async () => {
           if (poolsId.length < 2)
-            return console.log("test 'descending sort by apy' can't run because no suitable pools were found");
-          const { pageResults, totalResultCount } = await query(filters, { field: 'apy', order: 'desc' });
+            return console.log(`test 'descending sort by ${field}' can't run because no suitable pools were found`);
+
+          const { pageResults, totalResultCount } = await query(filters, { field, order: 'desc' });
 
           expect(totalResultCount).toBe(poolsId.length);
-          expect(pageResults.map((p) => p.metrics?.apy)).toStrictEqual(
+          expect(pageResults.map((p) => p.metrics?.[field])).toStrictEqual(
             pools
               .filter(({ id }) => poolsId.includes(id))
-              .sort((a, b) => (a.metrics!.apy! > b.metrics!.apy! ? -1 : 1))
-              .map((p) => p.metrics?.apy)
+              .sort((a, b) => (a.metrics![field]! > b.metrics![field]! ? -1 : 1))
+              .map((p) => p.metrics![field])
           );
         });
       });

package/test/wallet/PersonalWallet/delegation.test.ts

@@ -1,10 +1,12 @@
 /* eslint-disable max-statements */
+import * as Crypto from '@cardano-sdk/crypto';
 import { BigIntMath } from '@cardano-sdk/util';
 import { Cardano } from '@cardano-sdk/core';
 import { ObservableWallet, PersonalWallet } from '@cardano-sdk/wallet';
 import {
   TX_TIMEOUT_DEFAULT,
   TestWallet,
+  bip32Ed25519Factory,
   firstValueFromTimed,
   getEnv,
   getWallet,
@@ -27,6 +29,7 @@ const getWalletStateSnapshot = async (wallet: ObservableWallet) => {
   const utxoTotal = await firstValueFrom(wallet.utxo.total$);
   const utxoAvailable = await firstValueFrom(wallet.utxo.available$);
   const rewardsBalance = await firstValueFrom(wallet.balance.rewardAccounts.rewards$);
+
   return {
     balance: { available: balanceAvailable, deposit, total: balanceTotal },
     epoch: epoch.epochNo,
@@ -54,6 +57,7 @@ const waitForTx = async (wallet: ObservableWallet, hash: Cardano.TransactionId)
 describe('PersonalWallet/delegation', () => {
   let wallet1: TestWallet;
   let wallet2: TestWallet;
+  let bip32Ed25519: Crypto.Bip32Ed25519;
 
   beforeAll(async () => {
     jest.setTimeout(180_000);
@@ -61,6 +65,7 @@ describe('PersonalWallet/delegation', () => {
     wallet2 = await getWallet({ env, idx: 1, logger, name: 'Test Wallet 2', polling: { interval: 500 } });
 
     await Promise.all([waitForWalletStateSettle(wallet1.wallet), waitForWalletStateSettle(wallet2.wallet)]);
+    bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
   });
 
   afterAll(() => {
@@ -164,9 +169,7 @@ describe('PersonalWallet/delegation', () => {
       expect(tx1ConfirmedState.rewardAccount.delegatee?.currentEpoch?.id).toEqual(poolId);
     }
 
-    const stakeKeyHash = await (
-      await sourceWallet.keyAgent.getBip32Ed25519()
-    ).getPubKeyHash(tx1ConfirmedState.publicStakeKey.publicStakeKey);
+    const stakeKeyHash = await bip32Ed25519.getPubKeyHash(tx1ConfirmedState.publicStakeKey.publicStakeKey);
     expect(stakeKeyHash).toEqual(Cardano.RewardAccount.toHash(tx1ConfirmedState.rewardAccount.address));
     expect(tx1ConfirmedState.publicStakeKey.keyStatus).toBe(Cardano.StakeKeyStatus.Registered);
 

package/test/wallet/PersonalWallet/handle.test.ts

@@ -3,6 +3,7 @@ import { Cardano, metadatum } from '@cardano-sdk/core';
 import { KeyAgent, TransactionSigner } from '@cardano-sdk/key-management';
 import { PersonalWallet } from '@cardano-sdk/wallet';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   coinsRequiredByHandleMint,
   createHandleMetadata,
@@ -49,7 +50,7 @@ describe('Ada handle', () => {
     keyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       await firstValueFrom(wallet.genesisParameters$),
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
     ({ policyScript, policySigner, policyId } = await createHandlePolicy(keyAgent));
     const handleProviderPolicyId = await getHandlePolicyId(

package/test/wallet/PersonalWallet/mint.test.ts

@@ -3,6 +3,7 @@ import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   getEnv,
@@ -36,7 +37,7 @@ describe('PersonalWallet/mint', () => {
     const aliceKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     const derivationPath = {

package/test/wallet/PersonalWallet/multiAddress.test.ts

@@ -3,6 +3,7 @@ import { AddressType, GroupedAddress, util } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import {
   KeyAgentFactoryProps,
+  bip32Ed25519Factory,
   createStandaloneKeyAgent,
   firstValueFromTimed,
   getWallet,
@@ -42,7 +43,7 @@ describe('PersonalWallet/multiAddress', () => {
     const multiAddressKeyAgent = await createStandaloneKeyAgent(
       mnemonics,
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     let txBuilder = wallet.createTxBuilder();

package/test/wallet/PersonalWallet/multisignature.test.ts

@@ -4,6 +4,7 @@ import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   getEnv,
@@ -34,15 +35,16 @@ describe('PersonalWallet/multisignature', () => {
 
     const genesis = await firstValueFrom(wallet.genesisParameters$);
 
+    const bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
     const aliceKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      bip32Ed25519
     );
     const bobKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      bip32Ed25519
     );
 
     const aliceDerivationPath = {

package/test/wallet/PersonalWallet/nft.test.ts

@@ -4,6 +4,7 @@ import { Assets, FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, TransactionSigner, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   firstValueFromTimed,
@@ -60,7 +61,7 @@ describe('PersonalWallet.assets/nft', () => {
     const keyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     const derivationPath = {

package/test/web-extension/extension/ui.ts

@@ -165,10 +165,7 @@ const deactivateWallet = async (): Promise<void> => {
   clearWalletValues();
 };
 
-/**
- * Wallet does not have any active delegations.
- * Show a `<p class="noDelegation">No delegation found</p>`
- */
+/** Wallet does not have any active delegations. Show a `<p class="noDelegation">No delegation found</p>` */
 const createEmptyDelegationEl = () => {
   const emptyDistribution = document.createElement('p');
   emptyDistribution.classList.add('noDelegation');
@@ -176,10 +173,7 @@ const createEmptyDelegationEl = () => {
   return emptyDistribution;
 };
 
-/**
- * Create a list item for a delegation
- * `<li> <span class="poolId">thePoolId</span> <span class="percent">50</span> </li>`
- */
+/** Create a list item for a delegation `<li> <span class="poolId">thePoolId</span> <span class="percent">50</span> </li>` */
 const createDelegationLi = (poolId: string, percent: string) => {
   const delegationLi = document.createElement('li');
   const poolIdSpan = document.createElement('span');