@cardano-sdk/e2e 0.14.2 → 0.16.0

package/docker-compose.yml

@@ -12,6 +12,10 @@ services:
     <<: *logging
     build:
       context: ./local-network
+    depends_on:
+      # We need the file server here in order to calculate the pool metadata hashes
+      file-server:
+        condition: service_healthy
     environment:
       CARDANO_NODE_LOG_LEVEL: ${CARDANO_NODE_LOG_LEVEL:-Info}
       CARDANO_NODE_CHAINDB_LOG_LEVEL: ${CARDANO_NODE_CHAINDB_LOG_LEVEL:-Notice}
@@ -20,10 +24,7 @@ services:
     volumes:
       - ./local-network/network-files/node-sp1/:/root/network-files/node-sp1
       - ./local-network/config:/root/config
-    depends_on:
-      # We need the file server here in order to calculate the pool metadata hashes
-      file-server:
-        condition: service_healthy
+      - sdk-ipc:/sdk-ipc
 
   file-server:
     <<: *logging
@@ -39,12 +40,15 @@ services:
       timeout: 10s
 
   cardano-node-ogmios:
+    entrypoint: [ "/tini", "-g", "--", "/scripts/cardano-node-ogmios.sh" ]
     image: cardanosolutions/cardano-node-ogmios:v${OGMIOS_VERSION:-5.6.0}_${CARDANO_NODE_VERSION:-1.35.5}
     depends_on:
       local-testnet:
         condition: service_healthy
     volumes:
       - ./local-network/config/network:/config
+      - ./local-network/scripts:/scripts
+      - sdk-ipc:/sdk-ipc
 
   cardano-db-sync:
     depends_on:
@@ -72,6 +76,12 @@ services:
         condition: service_healthy
     restart: on-failure
 
+  handle-projector:
+    environment:
+      HANDLE_POLICY_IDS_FILE: /sdk-ipc/handle_policy_ids
+    volumes:
+      - sdk-ipc:/sdk-ipc
+
   provider-server:
     environment:
       TOKEN_METADATA_SERVER_URL: stub://
@@ -79,4 +89,10 @@ services:
       - ./local-network/config/network:/config
 
 volumes:
+  sdk-ipc:
+    driver: local
+    driver_opts:
+      device: ./local-network/sdk-ipc
+      o: bind
+      type: none
   wallet-db:

package/local-network/scripts/cardano-node-ogmios.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Simple scripts which overrides the original cardano-node-ogmios.sh file from the
+# cardano-node-ogmios docker image.
+
+# Used to support the e2e test to check the projector is able to
+# connect / reconnect to the ogmios server.
+
+# If the test set the file, wait for its removal before starting the container
+while [ -f /sdk-ipc/prevent_ogmios ] ; do sleep 10 ; done
+
+# Start the cardano-node-ogmios as normal
+/root/cardano-node-ogmios.sh

package/local-network/scripts/mint-handles.sh

@@ -25,6 +25,7 @@ cat >network-files/utxo-keys/handles-metadata.json <<EOL
 }}
 EOL
 
+echo $policyid > /sdk-ipc/handle_policy_ids
 
 addr=$(cardano-cli address build --payment-verification-key-file network-files/utxo-keys/utxo1.vkey --testnet-magic 888)
 faucetAddr="addr_test1qqen0wpmhg7fhkus45lyv4wju26cecgu6avplrnm6dgvuk6qel5hu3u3q0fht53ly97yx95hkt56j37ch07pesf6s4pqh5gd4e"

package/local-network/sdk-ipc/README.md

@@ -0,0 +1,5 @@
+## Description
+
+Empty directory used as IPC between SDK containers and with the extern.
+
+Used for files required by tests or to share ADA handle policy id between containers, etc...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "engines": {
     "node": ">=16.0"
@@ -81,18 +81,18 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^6.0.0",
     "@cardano-ogmios/client": "5.6.0",
-    "@cardano-sdk/cardano-services": "~0.13.2",
-    "@cardano-sdk/cardano-services-client": "~0.9.8",
-    "@cardano-sdk/core": "~0.14.1",
-    "@cardano-sdk/crypto": "~0.1.6",
-    "@cardano-sdk/hardware-ledger": "~0.2.7",
-    "@cardano-sdk/key-management": "~0.7.6",
-    "@cardano-sdk/ogmios": "~0.12.4",
-    "@cardano-sdk/tx-construction": "~0.7.2",
-    "@cardano-sdk/util": "~0.11.0",
-    "@cardano-sdk/util-dev": "~0.13.2",
-    "@cardano-sdk/util-rxjs": "~0.4.15",
-    "@cardano-sdk/wallet": "~0.16.2",
+    "@cardano-sdk/cardano-services": "~0.14.0",
+    "@cardano-sdk/cardano-services-client": "~0.10.0",
+    "@cardano-sdk/core": "~0.15.1",
+    "@cardano-sdk/crypto": "~0.1.7",
+    "@cardano-sdk/hardware-ledger": "~0.2.9",
+    "@cardano-sdk/key-management": "~0.7.8",
+    "@cardano-sdk/ogmios": "~0.12.6",
+    "@cardano-sdk/tx-construction": "~0.8.1",
+    "@cardano-sdk/util": "~0.12.0",
+    "@cardano-sdk/util-dev": "~0.13.4",
+    "@cardano-sdk/util-rxjs": "~0.5.0",
+    "@cardano-sdk/wallet": "~0.17.0",
     "@vespaiach/axios-fetch-adapter": "^0.3.0",
     "axios": "^0.27.2",
     "bunyan": "^1.8.15",
@@ -122,16 +122,17 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.9.6",
-    "@cardano-sdk/projection": "~0.6.8",
-    "@cardano-sdk/projection-typeorm": "~0.3.4",
-    "@cardano-sdk/web-extension": "~0.12.4",
+    "@cardano-sdk/dapp-connector": "~0.9.8",
+    "@cardano-sdk/projection": "~0.6.10",
+    "@cardano-sdk/projection-typeorm": "~0.3.6",
+    "@cardano-sdk/web-extension": "~0.13.1",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
     "@types/chalk": "^2.2.0",
     "@types/convict": "^6.1.2",
     "@types/delay": "^3.1.0",
+    "@types/dockerode": "^3.3.8",
     "@types/jest": "^28.1.2",
     "@types/lodash": "^4.14.182",
     "@types/ora": "^3.2.0",
@@ -146,7 +147,7 @@
     "babel-loader": "^8.2.5",
     "blake2b-no-wasm": "2.1.4",
     "buffer": "^6.0.3",
-    "chromedriver": "^112.0.0",
+    "chromedriver": "^114.0.0",
     "copy-webpack-plugin": "^10.2.4",
     "eslint": "^7.32.0",
     "events": "^3.3.0",
@@ -173,5 +174,5 @@
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
-  "gitHead": "badfa920af582c12079ce55bf74ba7337d9cc3cb"
+  "gitHead": "46029ae65c25ce6cfef394249c7ff5a32259757f"
 }

package/src/factories.ts

@@ -100,7 +100,13 @@ assetProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger)
   if (params.baseUrl === undefined) throw new Error(`${assetInfoHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
   return new Promise<AssetProvider>(async (resolve) => {
-    resolve(assetInfoHttpProvider({ adapter: customHttpFetchAdapter, baseUrl: params.baseUrl, logger }));
+    resolve(
+      assetInfoHttpProvider({
+        adapter: customHttpFetchAdapter,
+        baseUrl: params.baseUrl,
+        logger
+      })
+    );
   });
 });
 

package/test/long-running/cache-invalidation.test.ts

@@ -47,7 +47,7 @@ describe('cache invalidation', () => {
 
   afterAll(() => wallet1.wallet.shutdown());
 
-  test('cache is invalidated on epoch rollover', async () => {
+  test.skip('cache is invalidated on epoch rollover', async () => {
     const wallet = wallet1.wallet;
 
     await walletReady(wallet);

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

@@ -5,10 +5,8 @@ import {
   getEnv,
   getTxConfirmationEpoch,
   getWallet,
-  requestCoins,
   runningAgainstLocalNetwork,
   submitAndConfirm,
-  transferCoins,
   waitForEpoch,
   walletVariables
 } from '../../src';
@@ -24,9 +22,6 @@ describe('delegation rewards', () => {
   let wallet2: PersonalWallet;
 
   const initializeWallets = async () => {
-    const amountFromFaucet = 100_000_000_000n;
-    const tAdaToSend = 50_000_000n;
-
     ({ wallet: wallet1, providers } = await getWallet({
       env,
       logger,
@@ -35,9 +30,6 @@ describe('delegation rewards', () => {
     }));
     ({ wallet: wallet2 } = await getWallet({ env, logger, name: 'Receiving Wallet', polling: { interval: 50 } }));
 
-    await requestCoins({ coins: amountFromFaucet, wallet: wallet1 });
-    await transferCoins({ coins: tAdaToSend, fromWallet: wallet1, toWallet: wallet2 });
-
     await waitForWalletStateSettle(wallet1);
     await waitForWalletStateSettle(wallet2);
   };
@@ -70,7 +62,13 @@ describe('delegation rewards', () => {
 
     const submitDelegationTx = async () => {
       logger.info(`Creating delegation tx at epoch #${(await firstValueFrom(wallet1.currentEpoch$)).epochNo}`);
-      const { tx: signedTx } = await wallet1.createTxBuilder().delegate(poolId).build().sign();
+      const { tx: signedTx } = await wallet1
+        .createTxBuilder()
+        .delegatePortfolio({
+          pools: [{ id: Cardano.PoolIdHex(Cardano.PoolId.toKeyHash(poolId)), weight: 1 }]
+        })
+        .build()
+        .sign();
       await wallet1.submitTx(signedTx);
       const { epochNo } = await firstValueFrom(wallet1.currentEpoch$);
       logger.info(`Delegation tx ${signedTx.id} submitted at epoch #${epochNo}`);

package/test/long-running/projector-ogmios-connection.test.ts

@@ -0,0 +1,132 @@
+import * as envalid from 'envalid';
+import { DockerUtil } from '@cardano-sdk/util-dev';
+import { open, rm } from 'fs/promises';
+import Dockerode from 'dockerode';
+import axios, { AxiosResponse } from 'axios';
+import delay from 'delay';
+import path from 'path';
+
+const preventOgmiosStartFile = path.join(__dirname, '..', '..', 'local-network', 'sdk-ipc', 'prevent_ogmios');
+
+const docker = new Dockerode();
+
+const ogmiosContainer = docker.getContainer('local-network-e2e-cardano-node-ogmios-1');
+const stakePoolProjectorContainer = docker.getContainer('local-network-e2e-stake-pool-projector-1');
+
+const createPrevent = async () => {
+  const file = await open(preventOgmiosStartFile, 'a');
+
+  await file.close();
+};
+
+const removePrevent = () => rm(preventOgmiosStartFile, { force: true });
+
+const killContainer = async (container: DockerUtil.Docker.Container) => {
+  // This waits only for the signal to be sent
+  await DockerUtil.containerExec(container, ['kill', '1']);
+  // Let's wait one more second to ensure the container was shut down
+  await delay(1000);
+};
+
+describe('projector ogmios connection', () => {
+  let stakePoolProjectorUrl: string;
+
+  const fetchProjectorHealth = async () => {
+    let result: AxiosResponse;
+
+    try {
+      result = await axios.post(stakePoolProjectorUrl, {});
+    } catch (error) {
+      if (axios.isAxiosError(error)) throw new Error(error.message);
+
+      throw error;
+    }
+
+    return result;
+  };
+
+  const checkProjector = async () => {
+    const health = await fetchProjectorHealth();
+
+    if (!health.data.ok) throw new Error('Projector not healthy');
+
+    const { blockNo } = health.data.services[0].projectedTip;
+    const start = Date.now();
+
+    // Wait for another block to be projected to ensure projector is working correctly
+    while ((await fetchProjectorHealth()).data.services[0].projectedTip.blockNo === blockNo) {
+      if (Date.now() - start > 60_000) throw new Error('The projector is not projecting new blocks');
+
+      await delay(100);
+    }
+  };
+
+  const waitProjector = async (skipOkCheck = false, tolerateConnectionErrors = false) => {
+    const start = Date.now();
+    let projectorReady = false;
+
+    do {
+      try {
+        const health = await fetchProjectorHealth();
+
+        if ('ok' in health.data && (skipOkCheck || health.data.ok)) projectorReady = true;
+      } catch (error) {
+        if (error && !tolerateConnectionErrors) throw error;
+      }
+
+      if (Date.now() - start > 60_000) throw new Error("The projector can't get ready");
+    } while (projectorReady === false);
+  };
+
+  beforeAll(() => {
+    const env = envalid.cleanEnv(process.env, { STAKE_POOL_PROJECTOR_URL: envalid.url() });
+
+    stakePoolProjectorUrl = `${env.STAKE_POOL_PROJECTOR_URL}health`;
+  });
+
+  beforeEach(async () => {
+    await removePrevent();
+    await checkProjector();
+  });
+
+  afterEach(() => removePrevent());
+
+  it.skip('projector reconnects after a short delay', async () => {
+    await killContainer(ogmiosContainer);
+    await waitProjector();
+    // This throws because is not able to complete HTTP request
+    await checkProjector();
+  });
+
+  // Once the problem which prevent the original test to work is solved
+  // the original test can be un-skipped and this one can be removed
+  it('projector reconnects after a short delay - alternative', async () => {
+    await killContainer(ogmiosContainer);
+    // Add a 10" sleep as a quick workaround for HTTP connection issue
+    await delay(10_000);
+    await waitProjector();
+    await checkProjector();
+  });
+
+  it.skip('projector reconnects after a long delay', async () => {
+    await createPrevent();
+    await killContainer(ogmiosContainer);
+    await delay(120_000);
+    await removePrevent();
+    await waitProjector();
+    await checkProjector();
+  });
+
+  it('projector connects to a later started ogmios', async () => {
+    await createPrevent();
+    await killContainer(ogmiosContainer);
+    await killContainer(stakePoolProjectorContainer);
+    await waitProjector(true, true);
+    await removePrevent();
+    // Once the 'projector reconnects after a short delay' problem is solved
+    // also remove following line and uncomment next one
+    await waitProjector(false, true);
+    // await waitProjector();
+    await checkProjector();
+  });
+});

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

@@ -113,7 +113,7 @@ describe('PersonalWallet/delegation', () => {
 
     const { tx } = await txBuilder
       .addOutput(await txBuilder.buildOutput().address(destAddresses).coin(tx1OutputCoins).build())
-      .delegate(poolId)
+      .delegatePortfolio({ pools: [{ id: Cardano.PoolIdHex(Cardano.PoolId.toKeyHash(poolId)), weight: 1 }] })
       .build()
       .sign();
     await sourceWallet.submitTx(tx);
@@ -163,7 +163,7 @@ describe('PersonalWallet/delegation', () => {
     }
 
     // Make a 2nd tx with key de-registration
-    const { tx: txDeregisterSigned } = await sourceWallet.createTxBuilder().delegate().build().sign();
+    const { tx: txDeregisterSigned } = await sourceWallet.createTxBuilder().delegatePortfolio(null).build().sign();
     await sourceWallet.submitTx(txDeregisterSigned);
     await waitForTx(sourceWallet, txDeregisterSigned.id);
     const tx2ConfirmedState = await getWalletStateSnapshot(sourceWallet);

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

@@ -1,4 +1,3 @@
-import { AddressType } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import { DelegatedStake, PersonalWallet, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
 import { MINUTE, firstValueFromTimed, getWallet, submitAndConfirm, walletReady } from '../../../src';
@@ -6,29 +5,17 @@ import { Observable, filter, firstValueFrom, map, tap } from 'rxjs';
 import { Percent } from '@cardano-sdk/util';
 import { createLogger } from '@cardano-sdk/util-dev';
 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 POOLS_COUNT = 5;
 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) => {
+const fundWallet = async (wallet: PersonalWallet) => {
   await walletReady(wallet, 0n);
   const addresses = await firstValueFrom(wallet.addresses$);
-  expect(addresses.length).toBeGreaterThan(1);
 
   // Check that we have enough funds. Otherwise, fund it from wallet account at index 0
   let { coins: totalCoins } = await firstValueFrom(wallet.balance.utxo.available$);
@@ -50,22 +37,6 @@ const distributeFunds = async (wallet: PersonalWallet) => {
     await walletReady(wallet);
     totalCoins = (await firstValueFrom(wallet.balance.utxo.available$)).coins;
   }
-
-  const coinsPerAddress = totalCoins / BigInt(addresses.length);
-
-  const txBuilder = wallet.createTxBuilder();
-
-  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());
-  }
-
-  const { tx: signedTx } = await txBuilder.build().sign();
-  await submitAndConfirm(wallet, signedTx);
 };
 
 /** await for rewardAccounts$ to be registered, unregistered, as defined in states   */
@@ -97,7 +68,7 @@ const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> =>
   } catch {
     // Some stake keys are registered. Deregister them
     const txBuilder = wallet.createTxBuilder();
-    txBuilder.delegate();
+    txBuilder.delegatePortfolio(null);
     const { tx: deregTx } = await txBuilder.build().sign();
     await submitAndConfirm(wallet, deregTx);
 
@@ -109,36 +80,44 @@ const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> =>
   }
 };
 
-const getPoolIds = async (wallet: PersonalWallet, count: number): Promise<Cardano.StakePool[]> => {
+const getPoolIds = async (wallet: PersonalWallet): Promise<Cardano.StakePool[]> => {
   const activePools = await wallet.stakePoolProvider.queryStakePools({
     filters: { status: [Cardano.StakePoolStatus.Active] },
-    pagination: { limit: count, startAt: 0 }
+    pagination: { limit: POOLS_COUNT, startAt: 0 }
   });
-  expect(activePools.pageResults.length).toBeGreaterThanOrEqual(count);
-  return Array.from({ length: count }).map((_, index) => activePools.pageResults[index]);
+  expect(activePools.pageResults.length).toBeGreaterThanOrEqual(POOLS_COUNT);
+  return Array.from({ length: POOLS_COUNT }).map((_, index) => activePools.pageResults[index]);
 };
 
-const delegateToMultiplePools = async (wallet: PersonalWallet) => {
-  // Delegating to multiple pools should be added in TxBuilder. Doing it manually for now.
-  // Prepare stakeKey registration certificates
-  const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
-  const stakeKeyRegCertificates = rewardAccounts.map(({ address }) => Cardano.createStakeKeyRegistrationCert(address));
-
-  const poolIds = await getPoolIds(wallet, rewardAccounts.length);
-  const delegationCertificates = rewardAccounts.map(({ address }, index) =>
-    Cardano.createDelegationCert(address, poolIds[index].id)
-  );
+/** Delegate to unique POOLS_COUNT pools. Use even distribution as default. */
+const delegateToMultiplePools = async (
+  wallet: PersonalWallet,
+  weights = Array.from({ length: POOLS_COUNT }).map(() => 1)
+) => {
+  const poolIds = await getPoolIds(wallet);
+  const portfolio: Pick<Cardano.Cip17DelegationPortfolio, 'pools'> = {
+    pools: poolIds.map(({ hexId: id }, idx) => ({ id, weight: weights[idx] }))
+  };
+  logger.debug('Delegating portfolio', portfolio);
+
+  const { tx } = await wallet.createTxBuilder().delegatePortfolio(portfolio).build().sign();
+  await submitAndConfirm(wallet, tx);
+  return poolIds;
+};
 
-  logger.debug(
-    `Delegating to pools ${poolIds.map(({ id }) => id)} and registering ${stakeKeyRegCertificates.length} stake keys`
+const delegateAllToSinglePool = async (wallet: PersonalWallet): Promise<void> => {
+  // This is a negative testcase, simulating an HD wallet that has multiple stake keys delegated
+  // to the same stake pool. txBuilder.delegatePortfolio does not support this scenario.
+  const [{ id: poolId }] = await getPoolIds(wallet);
+  const txBuilder = wallet.createTxBuilder();
+  const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
+  txBuilder.partialTxBody.certificates = rewardAccounts.map(({ address }) =>
+    Cardano.createDelegationCert(address, poolId)
   );
 
-  const txBuilder = wallet.createTxBuilder();
-  // Artificially add the certificates in TxBuilder. An api improvement will make the UX better
-  txBuilder.partialTxBody.certificates = [...stakeKeyRegCertificates, ...delegationCertificates];
+  logger.debug(`Delegating all stake keys to pool ${poolId}`);
   const { tx } = await txBuilder.build().sign();
   await submitAndConfirm(wallet, tx);
-  return poolIds;
 };
 
 describe('PersonalWallet/delegationDistribution', () => {
@@ -146,9 +125,8 @@ describe('PersonalWallet/delegationDistribution', () => {
 
   beforeAll(async () => {
     wallet = (await getWallet({ env, idx: 3, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;
-    await deriveStakeKeys(wallet);
+    await fundWallet(wallet);
     await deregisterAllStakeKeys(wallet);
-    await distributeFunds(wallet);
   });
 
   afterAll(() => {
@@ -158,19 +136,16 @@ 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);
+    const walletAddresses = await firstValueFromTimed(wallet.addresses$);
+    const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
+
+    expect(rewardAccounts.length).toBe(POOLS_COUNT);
 
     // Check that reward addresses were delegated
     await walletReady(wallet);
@@ -204,20 +179,11 @@ describe('PersonalWallet/delegationDistribution', () => {
 
     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
-    const { coins: totalCoins } = await firstValueFrom(wallet.balance.utxo.total$);
-    let txBuilder = wallet.createTxBuilder();
-    const { tx: txMoveFunds } = await txBuilder
-      .addOutput(
-        txBuilder
-          .buildOutput()
-          .address(walletAddresses[walletAddresses.length - 1].address)
-          .coin(totalCoins - 2_000_000n) // leave some behind for fees
-          .toTxOut()
-      )
-      .build()
-      .sign();
-    await submitAndConfirm(wallet, txMoveFunds);
+    // Delegate so that last address has all funds
+    await delegateToMultiplePools(
+      wallet,
+      Array.from({ length: POOLS_COUNT }).map((_, idx) => (POOLS_COUNT === idx + 1 ? 1 : 0))
+    );
 
     let simplifiedDelegationDistribution: Partial<DelegatedStake>[] = await firstValueFrom(
       wallet.delegation.distribution$.pipe(
@@ -246,9 +212,7 @@ describe('PersonalWallet/delegationDistribution', () => {
     );
 
     // Delegate all reward accounts to the same pool. delegationDistribution$ should have 1 entry with 100% distribution
-    txBuilder = wallet.createTxBuilder();
-    const { tx: txDelegateTo1Pool } = await txBuilder.delegate(poolIds[0].id).build().sign();
-    await submitAndConfirm(wallet, txDelegateTo1Pool);
+    await delegateAllToSinglePool(wallet);
     simplifiedDelegationDistribution = await firstValueFrom(
       wallet.delegation.distribution$.pipe(
         tap((distribution) => {

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

@@ -68,7 +68,7 @@ describe('Ada handle', () => {
   let policyScript: Cardano.NativeScript;
   let assetIds: Cardano.AssetId[];
 
-  const assetNames = ['6861646e6c6531', '6861646e6c6532'];
+  const assetNames = ['68616e646c6531', '68616e646c6532'];
   let walletAddress: Cardano.PaymentAddress;
   const coins = 2_000_000n; // number of coins to use in each transaction
 

package/test/web-extension/extension/background/services.ts

@@ -1,15 +1,30 @@
 // Expose any additional services to be shared with UIs
-import { BackgroundServices, adaPriceProperties, logger } from '../util';
+import { BackgroundServices, adaPriceProperties, env, logger } from '../util';
+import { Cardano } from '@cardano-sdk/core';
 import { adaPriceServiceChannel, walletName } from '../const';
 import { authenticator } from './authenticator';
 import { exposeApi, exposeSupplyDistributionTracker } from '@cardano-sdk/web-extension';
 import { of } from 'rxjs';
 import { runtime } from 'webextension-polyfill';
+import { stakePoolProviderFactory } from '../../../../src';
 import { supplyDistributionTrackerReady } from './supplyDistributionTracker';
 
 const priceService: BackgroundServices = {
   adaUsd$: of(2.99),
-  clearAllowList: authenticator.clear.bind(authenticator)
+  clearAllowList: authenticator.clear.bind(authenticator),
+  getPoolIds: async (count: number): Promise<Cardano.StakePool[]> => {
+    const stakePoolProvider = await stakePoolProviderFactory.create(
+      env.STAKE_POOL_PROVIDER,
+      env.STAKE_POOL_PROVIDER_PARAMS,
+      logger
+    );
+
+    const activePools = await stakePoolProvider.queryStakePools({
+      filters: { status: [Cardano.StakePoolStatus.Active] },
+      pagination: { limit: count, startAt: 0 }
+    });
+    return activePools.pageResults.slice(0, count);
+  }
 };
 
 exposeApi(

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

@@ -27,6 +27,17 @@
   <div>Stake Address: <span id="stakeAddress">-</span></div>
   <div>Balance: <span id="balance">-</span></div>
   <div>Network-wide staked: <span id="supplyDistribution">-</span></div>
+  <div id="multiDelegation">
+    <div class="distribution">
+      <h3>Delegation distribution:</h3>
+      <ul></ul>
+    </div>
+    <div class="delegate">
+      <p>Available Pools: <span class="pools"></span></p>
+      <button>Delegate to multiple pools</button>
+      <p class="delegateTxId"></p>
+    </div>
+  </div>
   <button id="buildAndSignTx">Build & Sign TX</button>
   <div>Signature: <span id="signature">-</span></div>
   <script src="ui.js"></script>