@cardano-sdk/e2e 0.13.1 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "engines": {
     "node": ">=16.0"
@@ -80,18 +80,18 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^6.0.0",
     "@cardano-ogmios/client": "5.6.0",
-    "@cardano-sdk/cardano-services": "~0.12.1",
-    "@cardano-sdk/cardano-services-client": "~0.9.5",
-    "@cardano-sdk/core": "~0.13.0",
+    "@cardano-sdk/cardano-services": "~0.13.0",
+    "@cardano-sdk/cardano-services-client": "~0.9.6",
+    "@cardano-sdk/core": "~0.14.0",
     "@cardano-sdk/crypto": "~0.1.6",
-    "@cardano-sdk/hardware-ledger": "~0.2.4",
-    "@cardano-sdk/key-management": "~0.7.3",
-    "@cardano-sdk/ogmios": "~0.12.1",
-    "@cardano-sdk/tx-construction": "~0.6.0",
+    "@cardano-sdk/hardware-ledger": "~0.2.5",
+    "@cardano-sdk/key-management": "~0.7.4",
+    "@cardano-sdk/ogmios": "~0.12.2",
+    "@cardano-sdk/tx-construction": "~0.7.0",
     "@cardano-sdk/util": "~0.11.0",
-    "@cardano-sdk/util-dev": "~0.12.1",
-    "@cardano-sdk/util-rxjs": "~0.4.12",
-    "@cardano-sdk/wallet": "~0.15.0",
+    "@cardano-sdk/util-dev": "~0.13.0",
+    "@cardano-sdk/util-rxjs": "~0.4.13",
+    "@cardano-sdk/wallet": "~0.16.0",
     "@vespaiach/axios-fetch-adapter": "^0.3.0",
     "axios": "^0.27.2",
     "bunyan": "^1.8.15",
@@ -116,10 +116,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.9.4",
-    "@cardano-sdk/projection": "~0.6.5",
-    "@cardano-sdk/projection-typeorm": "~0.3.1",
-    "@cardano-sdk/web-extension": "~0.12.1",
+    "@cardano-sdk/dapp-connector": "~0.9.5",
+    "@cardano-sdk/projection": "~0.6.6",
+    "@cardano-sdk/projection-typeorm": "~0.3.2",
+    "@cardano-sdk/web-extension": "~0.12.2",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -164,5 +164,5 @@
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
-  "gitHead": "1e727698158588f87464c9a7f09ededfa4be9970"
+  "gitHead": "9567993a2d29031dda1a41411485b8f3e58aef06"
 }

package/src/factories.ts

@@ -83,7 +83,7 @@ export const handleProviderFactory = new ProviderFactory<HandleProvider>();
 addressDiscoveryFactory.register('SingleAddressDiscovery', async () => new SingleAddressDiscovery());
 addressDiscoveryFactory.register(
   'HDSequentialDiscovery',
-  async ({ chainHistoryProvider }) => new HDSequentialDiscovery(chainHistoryProvider, 20, 5)
+  async ({ chainHistoryProvider }) => new HDSequentialDiscovery(chainHistoryProvider, 20)
 );
 
 // bip32Ed25519
@@ -280,6 +280,7 @@ export type GetWalletProps = {
   logger: Logger;
   name: string;
   polling?: PollingConfig;
+  handlePolicyIds?: Cardano.PolicyId[];
   stores?: storage.WalletStores;
   customKeyParams?: KeyAgentFactoryProps;
   keyAgent?: AsyncKeyAgent;
@@ -311,7 +312,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, handlePolicyIds, stores, customKeyParams, keyAgent } = props;
   const providers = {
     addressDiscovery: await addressDiscoveryFactory.create(
       env.ADDRESS_DISCOVERY,
@@ -370,7 +371,7 @@ export const getWallet = async (props: GetWalletProps) => {
       ? () => Promise.resolve(keyAgent)
       : await keyManagementFactory.create(env.KEY_MANAGEMENT_PROVIDER, keyManagementParams, logger),
     createWallet: async (asyncKeyAgent: AsyncKeyAgent) =>
-      new PersonalWallet({ name, polling }, { ...providers, keyAgent: asyncKeyAgent, logger, stores }),
+      new PersonalWallet({ handlePolicyIds, name, polling }, { ...providers, keyAgent: asyncKeyAgent, logger, stores }),
     logger
   });
 

package/test/util.ts

@@ -315,20 +315,7 @@ export const burnTokens = async ({
 
   const signedTx = await wallet.finalizeTx(finalizeProps);
   await submitAndConfirm(wallet, signedTx);
-
-  // Wait until all assets are burned
-  await firstValueFromTimed(
-    wallet.balance.utxo.available$.pipe(
-      map(({ assets: availableAssets }) => availableAssets),
-      filter(
-        (availableAssets) =>
-          !availableAssets?.size ||
-          ![...tokens!].some(([id]) => [...availableAssets].some(([assetId]) => assetId === id))
-      )
-    ),
-    'Not all assets were burned',
-    FAST_OPERATION_TIMEOUT_DEFAULT
-  );
+  await txConfirmed(wallet, signedTx);
 };
 
 export const mapToGroupedAddress = (addrModel: AddressesModel): GroupedAddress => ({

package/test/wallet/PersonalWallet/delegationDistribution.test.ts

@@ -1,3 +1,4 @@
+import { AddressType } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import { DelegatedStake, PersonalWallet, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
 import { MINUTE, getWallet } from '../../../src';
@@ -6,10 +7,23 @@ import { Percent } from '@cardano-sdk/util';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { firstValueFromTimed, submitAndConfirm, walletReady } from '../../util';
 import { getEnv, walletVariables } from '../../../src/environment';
+import delay from 'delay';
 
 const env = getEnv(walletVariables);
 const logger = createLogger();
 const TEST_FUNDS = 1_000_000_000n;
+const distributionMessage = 'ObservableWallet.delegation.distribution$:';
+
+const deriveStakeKeys = async (wallet: PersonalWallet) => {
+  await walletReady(wallet, 0n);
+  // Add 4 new addresses with different stake keys.
+  for (let i = 1; i < 5; ++i) {
+    await wallet.keyAgent.deriveAddress({ index: 0, type: AddressType.External }, i);
+  }
+  // Allow status tracker to change status with debounce.
+  // Otherwise the updates are be debounced and next calls find the wallet ready before it had a chance to update the status.
+  await delay(2);
+};
 
 /** Distribute the wallet funds evenly across all its addresses */
 const distributeFunds = async (wallet: PersonalWallet) => {
@@ -22,7 +36,7 @@ const distributeFunds = async (wallet: PersonalWallet) => {
 
   const coinDeficit = TEST_FUNDS - totalCoins;
   if (coinDeficit > 10_000_000n) {
-    logger.debug(
+    logger.info(
       `Insufficient funds in wallet account index 1. Missing ${coinDeficit}. Transferring from wallet account index 0`
     );
     const fundingWallet = (await getWallet({ env, idx: 0, logger, name: 'WalletAcct0', polling: { interval: 50 } }))
@@ -42,10 +56,12 @@ const distributeFunds = async (wallet: PersonalWallet) => {
 
   const txBuilder = wallet.createTxBuilder();
 
-  logger.debug(`Sending ${coinsPerAddress} to the ${addresses.length - 1} derived addresses`);
+  logger.info(`Sending ${coinsPerAddress} to the ${addresses.length - 1} derived addresses`);
   // The first one was generated when the wallet was created.
   for (let i = 1; i < addresses.length; ++i) {
     const derivedAddress = addresses[i];
+    logger.info('Funding', derivedAddress.address, coinsPerAddress);
+    logger.info(derivedAddress.rewardAccount);
     txBuilder.addOutput(txBuilder.buildOutput().address(derivedAddress.address).coin(coinsPerAddress).toTxOut());
   }
 
@@ -56,7 +72,8 @@ const distributeFunds = async (wallet: PersonalWallet) => {
 /** await for rewardAccounts$ to be registered, unregistered, as defined in states   */
 const rewardAccountStatuses = async (
   rewardAccounts$: Observable<Cardano.RewardAccountInfo[]>,
-  statuses: Cardano.StakeKeyStatus[]
+  statuses: Cardano.StakeKeyStatus[],
+  timeout = MINUTE
 ) =>
   firstValueFromTimed(
     rewardAccounts$.pipe(
@@ -65,21 +82,32 @@ const rewardAccountStatuses = async (
       filter((statusArr) => statusArr.every((s) => statuses.includes(s)))
     ),
     `Timeout waiting for all reward accounts stake keys to be one of ${statuses.join('|')}`,
-    MINUTE
+    timeout
   );
 
 /** Create stakeKey deregistration transaction for all reward accounts */
 const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> => {
-  const txBuilder = wallet.createTxBuilder();
-  txBuilder.delegate();
-  const { tx: deregTx } = await txBuilder.build().sign();
-  await submitAndConfirm(wallet, deregTx);
-
-  await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
-    Cardano.StakeKeyStatus.Unregistered,
-    Cardano.StakeKeyStatus.Unregistering
-  ]);
-  logger.debug('Deregistered all stake keys');
+  await walletReady(wallet, 0n);
+  try {
+    await rewardAccountStatuses(
+      wallet.delegation.rewardAccounts$,
+      [Cardano.StakeKeyStatus.Unregistered, Cardano.StakeKeyStatus.Unregistering],
+      0
+    );
+    logger.info('Stake keys are already deregistered');
+  } catch {
+    // Some stake keys are registered. Deregister them
+    const txBuilder = wallet.createTxBuilder();
+    txBuilder.delegate();
+    const { tx: deregTx } = await txBuilder.build().sign();
+    await submitAndConfirm(wallet, deregTx);
+
+    await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
+      Cardano.StakeKeyStatus.Unregistered,
+      Cardano.StakeKeyStatus.Unregistering
+    ]);
+    logger.info('Deregistered all stake keys');
+  }
 };
 
 const createStakeKeyRegistrationCert = (rewardAccount: Cardano.RewardAccount): Cardano.Certificate => ({
@@ -129,9 +157,10 @@ describe('PersonalWallet/delegationDistribution', () => {
   let wallet: PersonalWallet;
 
   beforeAll(async () => {
-    wallet = (await getWallet({ env, idx: 1, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;
-    await distributeFunds(wallet);
+    wallet = (await getWallet({ env, idx: 3, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;
+    await deriveStakeKeys(wallet);
     await deregisterAllStakeKeys(wallet);
+    await distributeFunds(wallet);
   });
 
   afterAll(() => {
@@ -140,14 +169,20 @@ describe('PersonalWallet/delegationDistribution', () => {
 
   it('reports observable wallet multi delegation as delegationDistribution by pool', async () => {
     await walletReady(wallet);
+
     const walletAddresses = await firstValueFromTimed(wallet.addresses$);
     const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
 
+    expect(rewardAccounts.length).toBe(5);
+
     // No stake distribution initially
     const delegationDistribution = await firstValueFrom(wallet.delegation.distribution$);
+    logger.info('Empty delegation distribution initially');
     expect(delegationDistribution).toEqual(new Map());
 
     const poolIds = await delegateToMultiplePools(wallet);
+    // Redistribute the funds because delegation costs send change to the first account, messing up the uniform distribution
+    await distributeFunds(wallet);
 
     // Check that reward addresses were delegated
     await walletReady(wallet);
@@ -176,6 +211,9 @@ describe('PersonalWallet/delegationDistribution', () => {
     }));
     const actualDelegationDistribution = await firstValueFrom(wallet.delegation.distribution$);
 
+    logger.info('Funds were distributed evenly across the addresses.');
+    logger.info(distributionMessage, actualDelegationDistribution);
+
     expect([...actualDelegationDistribution.values()]).toEqual(expectedDelegationDistribution);
 
     // Send all coins to the last address. Check that stake distribution is 100 for that address and 0 for the rest
@@ -195,6 +233,10 @@ describe('PersonalWallet/delegationDistribution', () => {
 
     let simplifiedDelegationDistribution: Partial<DelegatedStake>[] = await firstValueFrom(
       wallet.delegation.distribution$.pipe(
+        tap((delegatedStake) => {
+          logger.info('All funds were moved to', walletAddresses[walletAddresses.length - 1].address);
+          logger.info(distributionMessage, delegatedStake);
+        }),
         map((delegatedStake) =>
           [...delegatedStake.values()].map(({ pool, percentage }) => ({
             id: pool.id,
@@ -204,6 +246,7 @@ describe('PersonalWallet/delegationDistribution', () => {
         )
       )
     );
+
     expect(simplifiedDelegationDistribution).toEqual(
       rewardAccounts.map((_, index) => ({
         id: poolIds[index].id,
@@ -220,6 +263,10 @@ describe('PersonalWallet/delegationDistribution', () => {
     await submitAndConfirm(wallet, txDelegateTo1Pool);
     simplifiedDelegationDistribution = await firstValueFrom(
       wallet.delegation.distribution$.pipe(
+        tap((distribution) => {
+          logger.info('All stake keys are delegated to poolId:', poolIds[0].id);
+          logger.info(distributionMessage, distribution);
+        }),
         map((distribution) =>
           [...distribution.values()].map((delegatedStake) => ({
             id: delegatedStake.pool.id,

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

@@ -0,0 +1,271 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import { Cardano, metadatum, nativeScriptPolicyId } from '@cardano-sdk/core';
+import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
+import { InitializeTxProps } from '@cardano-sdk/tx-construction';
+import { KeyRole, TransactionSigner, util } from '@cardano-sdk/key-management';
+import { Metadatum, TokenMap } from '@cardano-sdk/core/dist/cjs/Cardano';
+import { burnTokens, createStandaloneKeyAgent, submitAndConfirm, txConfirmed, walletReady } from '../../util';
+import { createLogger } from '@cardano-sdk/util-dev';
+import { firstValueFrom } from 'rxjs';
+import { getEnv, getWallet, walletVariables } from '../../../src';
+
+const env = getEnv(walletVariables);
+const logger = createLogger();
+
+type HandleMetadata = {
+  [policyId: string]: {
+    [handleName: string]: {
+      augmentations: [];
+      core: {
+        handleEncoding: string;
+        og: number;
+        prefix: string;
+        termsofuse: string;
+        version: number;
+      };
+      description: string;
+      image: string;
+      name: string;
+      website: string;
+    };
+  };
+};
+
+const createHandleMetadata = (handlePolicyId: string, handleNames: string[]): HandleMetadata => {
+  const result: HandleMetadata[0] = {};
+  for (const key of handleNames) {
+    result[key] = {
+      augmentations: [],
+      core: {
+        handleEncoding: 'utf-8',
+        og: 0,
+        prefix: '$',
+        termsofuse: 'https://cardanofoundation.org/en/terms-and-conditions/',
+        version: 0
+      },
+      description: 'The Handle Standard',
+      image: 'ipfs://some-hash',
+      name: '$handle1',
+      website: 'https://cardano.org/'
+    };
+  }
+  return { [handlePolicyId]: result };
+};
+
+describe('Ada handle', () => {
+  let wallet: PersonalWallet;
+  let receivingWallet: PersonalWallet;
+  let policySigner: TransactionSigner;
+  let policyId: Cardano.PolicyId;
+  let policyScript: Cardano.NativeScript;
+  let assetIds: Cardano.AssetId[];
+
+  const assetNames = ['6861646e6c6531', '6861646e6c6532'];
+  let walletAddress: Cardano.PaymentAddress;
+  const coins = 2_000_000n; // number of coins to use in each transaction
+
+  const initPolicyId = async () => {
+    wallet = (await getWallet({ env, idx: 0, logger, name: 'Handle Init Wallet', polling: { interval: 50 } })).wallet;
+    await walletReady(wallet, coins);
+    const derivationPath = {
+      index: 2,
+      role: KeyRole.External
+    };
+    const keyAgent = await createStandaloneKeyAgent(
+      env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
+      await firstValueFrom(wallet.genesisParameters$),
+      await wallet.keyAgent.getBip32Ed25519()
+    );
+    const pubKey = await keyAgent.derivePublicKey(derivationPath);
+    const keyHash = await keyAgent.bip32Ed25519.getPubKeyHash(pubKey);
+    policySigner = new util.KeyAgentTransactionSigner(keyAgent, derivationPath);
+    policyScript = {
+      __type: Cardano.ScriptType.Native,
+      kind: Cardano.NativeScriptKind.RequireAllOf,
+      scripts: [
+        {
+          __type: Cardano.ScriptType.Native,
+          keyHash,
+          kind: Cardano.NativeScriptKind.RequireSignature
+        }
+      ]
+    };
+    policyId = nativeScriptPolicyId(policyScript);
+    wallet.shutdown();
+  };
+
+  const mint = async (tokens: Cardano.TokenMap, txMetadatum: Cardano.Metadatum) => {
+    const auxiliaryData = {
+      blob: new Map([[721n, txMetadatum]])
+    };
+
+    const txProps: InitializeTxProps = {
+      auxiliaryData,
+      mint: tokens,
+      outputs: new Set([
+        {
+          address: walletAddress,
+          value: {
+            assets: tokens,
+            coins
+          }
+        }
+      ]),
+      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+    };
+
+    const unsignedTx = await wallet.initializeTx(txProps);
+
+    const finalizeProps: FinalizeTxProps = {
+      auxiliaryData,
+      tx: unsignedTx,
+      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+    };
+
+    const signedTx = await wallet.finalizeTx(finalizeProps);
+    await submitAndConfirm(wallet, signedTx);
+  };
+
+  const restartWallet = async () => {
+    wallet.shutdown();
+    wallet = (
+      await getWallet({
+        env,
+        handlePolicyIds: [policyId],
+        idx: 0,
+        logger,
+        name: 'Minting Wallet',
+        polling: { interval: 50 }
+      })
+    ).wallet;
+    await walletReady(wallet, coins);
+  };
+
+  beforeAll(async () => {
+    await initPolicyId();
+    wallet = (
+      await getWallet({
+        env,
+        handlePolicyIds: [policyId],
+        idx: 0,
+        logger,
+        name: 'Minting Wallet',
+        polling: { interval: 50 }
+      })
+    ).wallet;
+    receivingWallet = (
+      await getWallet({
+        env,
+        handlePolicyIds: [policyId],
+        idx: 1,
+        logger,
+        name: 'Receiving Wallet',
+        polling: { interval: 50 }
+      })
+    ).wallet;
+    await Promise.all([walletReady(wallet, coins), walletReady(receivingWallet, 0n)]);
+    assetIds = [Cardano.AssetId(`${policyId}${assetNames[0]}`), Cardano.AssetId(`${policyId}${assetNames[1]}`)];
+    walletAddress = (await firstValueFrom(wallet.addresses$))[0].address;
+  });
+
+  afterEach(async () => {
+    await burnTokens({
+      policySigners: [policySigner],
+      scripts: [policyScript],
+      wallet
+    });
+    await burnTokens({
+      policySigners: [policySigner],
+      scripts: [policyScript],
+      wallet: receivingWallet
+    });
+  });
+
+  afterAll(async () => {
+    wallet.shutdown();
+    receivingWallet.shutdown();
+  });
+
+  it("PersonalWallet discovers it's own handles", async () => {
+    const tokens = new Map([
+      [assetIds[0], 1n],
+      [assetIds[1], 1n]
+    ]);
+    const txMetadatum = metadatum.jsonToMetadatum(createHandleMetadata(policyId, ['handle1', 'handle2']));
+    await mint(tokens, txMetadatum);
+    let utxo = await firstValueFrom(wallet.balance.utxo.available$);
+    let receivingUtxo = await firstValueFrom(receivingWallet.balance.utxo.available$);
+    expect(utxo.assets?.size).toEqual(2);
+    expect(receivingUtxo.assets).toBeUndefined();
+    let handles = await firstValueFrom(wallet.handles$);
+    let receivingHandles = await firstValueFrom(receivingWallet.handles$);
+    expect(handles.length).toEqual(2);
+    expect(receivingHandles.length).toEqual(0);
+
+    const token = new Map([[assetIds[0], 1n]]);
+    const destAddresses = (await firstValueFrom(receivingWallet.addresses$))[0].address;
+    const txBuilder = wallet.createTxBuilder();
+    const { tx } = await txBuilder
+      .addOutput(await txBuilder.buildOutput().address(destAddresses).coin(coins).assets(token).build())
+      .build()
+      .sign();
+    await wallet.submitTx(tx);
+    await txConfirmed(receivingWallet, tx);
+
+    utxo = await firstValueFrom(wallet.balance.utxo.available$);
+    receivingUtxo = await firstValueFrom(receivingWallet.balance.utxo.available$);
+    expect(utxo.assets?.size).toEqual(1);
+    expect(receivingUtxo.assets?.size).toEqual(1);
+    expect(receivingUtxo.assets?.keys().next().value).toEqual(assetIds[0]);
+    handles = await firstValueFrom(wallet.handles$);
+    receivingHandles = await firstValueFrom(receivingWallet.handles$);
+    expect(handles.length).toEqual(1);
+    expect(receivingHandles.length).toEqual(1);
+  });
+
+  describe('double mint handling', () => {
+    it('filters out double mints in separate transactions', async () => {
+      const tokens: TokenMap = new Map([[assetIds[0], 1n]]);
+      const txMetadatum: Metadatum = metadatum.jsonToMetadatum(createHandleMetadata(policyId, ['handle1']));
+      await mint(tokens, txMetadatum);
+      let handles = await firstValueFrom(wallet.handles$);
+      expect(handles.length).toEqual(1);
+      await mint(tokens, txMetadatum);
+      await restartWallet();
+      const utxo = await firstValueFrom(wallet.balance.utxo.available$);
+      expect(utxo.assets?.values().next().value).toEqual(2n);
+      handles = await firstValueFrom(wallet.handles$);
+      expect(handles).toEqual([]);
+    });
+
+    it('filters out double mints from within the same transaction', async () => {
+      const tokens = new Map([[assetIds[0], 2n]]);
+      const txMetadatum: Metadatum = metadatum.jsonToMetadatum(createHandleMetadata(policyId, ['handle1']));
+      await mint(tokens, txMetadatum);
+      await restartWallet();
+      const utxo = await firstValueFrom(wallet.balance.utxo.available$);
+      expect(utxo.assets?.values().next().value).toEqual(2n);
+      const handles = await firstValueFrom(wallet.handles$);
+      expect(handles).toEqual([]);
+    });
+
+    it('shows handle after corrective burn', async () => {
+      const tokens = new Map([[assetIds[0], 2n]]);
+      const txMetadatum: Metadatum = metadatum.jsonToMetadatum(createHandleMetadata(policyId, ['handle1']));
+      await mint(tokens, txMetadatum);
+      let utxo = await firstValueFrom(wallet.balance.utxo.available$);
+      expect(utxo.assets?.values().next().value).toEqual(2n);
+      await burnTokens({
+        policySigners: [policySigner],
+        scripts: [policyScript],
+        tokens: new Map([[assetIds[0], 1n]]),
+        wallet
+      });
+      await restartWallet();
+      utxo = await firstValueFrom(wallet.balance.utxo.available$);
+      expect(utxo.assets?.values().next().value).toEqual(1n);
+      const correctedHandles = await firstValueFrom(wallet.handles$);
+      expect(correctedHandles.length).toEqual(1);
+    });
+  });
+});

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

@@ -39,20 +39,7 @@ describe('PersonalWallet/multiAddress', () => {
 
     let txBuilder = wallet.createTxBuilder();
 
-    let addressesToBeDiscovered = new Array<GroupedAddress>();
-
-    // Let's add the 5 stake keys.
-    for (let i = 0; i < 5; ++i) {
-      addressesToBeDiscovered.push(
-        await multiAddressKeyAgent.deriveAddress(
-          {
-            index: 0,
-            type: AddressType.External
-          },
-          i
-        )
-      );
-    }
+    const addressesToBeDiscovered = new Array<GroupedAddress>();
 
     // Deposit some tADA at some generated addresses from the previously generated mnemonics.
     for (let i = 0; i < PAYMENT_ADDRESSES_TO_GENERATE; ++i) {
@@ -68,9 +55,6 @@ describe('PersonalWallet/multiAddress', () => {
       txBuilder.addOutput(txBuilder.buildOutput().address(address.address).coin(3_000_000n).toTxOut());
     }
 
-    // Remove duplicates
-    addressesToBeDiscovered = [...new Set(addressesToBeDiscovered)];
-
     const { tx: signedTx } = await txBuilder.build().sign();
 
     await wallet.submitTx(signedTx);