@cardano-sdk/e2e 0.16.6-patch.0 → 0.16.6

package/test/k6/scenarios/wallet-restoration.test.js

@@ -1,192 +1,330 @@
-import http from 'k6/http';
-import { check, sleep } from 'k6';
+/* eslint-disable no-console */
+/* eslint-disable func-style */
 import { Counter, Trend } from 'k6/metrics';
+import { check, sleep } from 'k6';
+import http from 'k6/http';
 
 /**
- * Script overall description:
- *  One wallet == one VU
- *  Configure RUN_MODE to have the test run with empty wallets (onboarding) or wallets with history (restoring)
- *  Configure MAX_VU: number of wallets to be synced (e.g. 100 wallets)
- *  Setup RAMP_UP_DURATION: ramp-up time to synced these wallets (e.g. 30s)
+ * #Script overall description:
+ *  - One wallet == one VU
+ *  - One wallet == 1 address for `RunMode.Onboard` and `RunMode.Restore`
+ *  - One wallet == n addresses for `RunMode.RestoreHD` mode
+ *  - Configure RUN_MODE to have the test run with empty wallets (onboarding), wallets with history (restoring) or HD wallets with history
+ *    and discovery phase.
+ *  - SDK `PersonalWallet` does HD discovery for every wallet, to determine the active addresses, so it will be done even for single address wallets.
+ *    To simulate this use `RunMode.RestoreHD` with `hdWalletParams.activeAddrCount: 1`.
+ *  - Configure MAX_VU: number of wallets to be synced (e.g. 100 wallets)
+ *  - Setup RAMP_UP_DURATION: ramp-up time to synced these wallets (e.g. 30s)
  *    - During this time, wallets start evenly distributed (e.g. ~3 wallets every second)
- *  Each wallet performs as many iterations as possible
- *    - 1st iteration: restoration steps .
+ *  - Each wallet performs as many iterations as possible
+ *    - 1st iteration: restoration steps.
  *    - Subsequent iterations will only query the tip
- *  ITERATION_SLEEP: Every iteration has a sleep of to simulate Lace tip polling interval
- *  During the STEADY_STATE_DURATION:
+ *  - ITERATION_SLEEP: Every iteration has a sleep of to simulate Lace tip polling interval
+ *  - During the STEADY_STATE_DURATION:
  *    - Synced wallets do tip queries.
  *    - Wallets not synced yet will wait for restoration to complete, then will also start tip queries
- *  No ramp-down is needed. We can simply stop the test as there is no point in sending fewer and fewer tip queries during ramp-down.
- *  wallet_sync: is a custom trend metric measuring the trend of wallet sync calls.
- *  wallet_sync_count: is a custom count metric measuring the number of wallets that were successfully synced.
+ *  - No ramp-down is needed. We can simply stop the test as there is no point in sending fewer and fewer tip queries during ramp-down.
+ *  - wallet_sync: is a custom trend metric measuring the trend of wallet sync calls.
+ *  - wallet_sync_count: is a custom count metric measuring the number of wallets that were successfully synced.
  */
 
 const RunMode = {
-    Onboard: 'Onboard',
-    Restore: 'Restore'
+  Onboard: 'Onboard',
+  Restore: 'Restore',
+  RestoreHD: 'RestoreHD'
 };
 /** Determines run mode: Restore or Onboard */
 const RUN_MODE = RunMode.Restore;
+
+// eslint-disable-next-line no-undef
 const PROVIDER_SERVER_URL = __ENV.PROVIDER_SERVER_URL;
 
 /** URL of the JSON file containing the wallets */
 const WALLET_ADDRESSES_URL =
-    RUN_MODE === RunMode.Restore
-        ? 'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/master/packages/e2e/test/dump/addresses/mainnet.json'
-        : 'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/feat/address-generator/packages/e2e/test/dump/addresses/no-history-mainnet.json';
+  RUN_MODE === RunMode.Onboard
+    ? 'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/master/packages/e2e/test/dump/addresses/no-history-mainnet.json'
+    : 'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/master/packages/e2e/test/dump/addresses/mainnet.json';
 
 /** URL of the JSON file containing the stake pool addresses */
 const POOL_ADDRESSES_URL =
-    'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/master/packages/e2e/test/dump/pool_addresses/mainnet.json';
+  'https://raw.githubusercontent.com/input-output-hk/cardano-js-sdk/master/packages/e2e/test/dump/pool_addresses/mainnet.json';
 
 /**
  * Define the maximum number of virtual users to simulate
- * The mainnet.json file contains wallets in chunks of 100, each chunk having the required distribution
- * For this reason, it's a good practice to configure MAX_VUs in multiples of 100 in order to maintain the desired distribution
+ * The mainnet.json file contains wallet addresses in chunks of 100, each chunk having the required distribution
+ * For this reason, it's a good practice to configure MAX_VUs in multiples of 100 in order to maintain the desired distribution.
+ * In `RunMode.RestoreHD`, each VU will have multiple addresses.
  */
-const MAX_VU = 1;
+const MAX_VU = 10;
 
 /** Time span during which all virtual users are started in a linear fashion */
-const RAMP_UP_DURATION = '5s';
+const RAMP_UP_DURATION = '10s';
 /** Time span during which synced wallets do tip queries */
-const STEADY_STATE_DURATION = '5s';
+const STEADY_STATE_DURATION = '20s';
 
 /** Time to sleep between iterations. Simulates polling tip to keep wallet in sync */
 const ITERATION_SLEEP = 5;
 
+/** HD wallet discovery. Used when RunMode is `RestoreHD` */
+const hdWalletParams = {
+  /** HD wallet size. The number of addresses with transaction history per wallet. They are queried at discover time. */
+  activeAddrCount: 10,
+  /** Use only addresses with a transaction history up to this value */
+  maxTxHistory: 100,
+  /** number of payment addresses to search for. It will search both internal and external address, thus multiplied by 2 */
+  paymentAddrSearchGap: 20 * 2,
+  /** number of stake keys to search for. It will search both internal and external address, thus multiplied by 2 */
+  stakeAddrSearchGap: 5 * 2
+};
+
 /** Custom trend statistic to measure trend to sync wallets */
 const walletSyncTrend = new Trend('wallet_sync', true);
 /** Custom count statistic to measure how many wallets were successfully syncd */
 const walletSyncCount = new Counter('wallet_sync_count');
 
-/** Grab the wallets json file to be used by the scenario */
+/** Repetitive endpoints */
+const TIP_URL = 'network-info/ledger-tip';
+
+/** equivalent to lodash.chunk */
+const chunkArray = (array, chunkSize) => {
+  const arrayCopy = [...array];
+  const chunked = [];
+  while (arrayCopy.length > 0) {
+    chunked.push(arrayCopy.splice(0, chunkSize));
+  }
+  return chunked;
+};
+
+/**
+ * Grab the wallets json file to be used by the scenario.
+ * Group the addresses per wallet (single address or HD wallets).
+ */
 export function setup() {
-    console.log(`Running in ${RUN_MODE} mode`);
-    let res = http.batch([WALLET_ADDRESSES_URL, POOL_ADDRESSES_URL]);
-    check(res, { 'get wallets and pools files': (r) => r.every(({ status }) => status >= 200 && status < 300) });
-
-    const [{ body: resBodyWallets }, { body: resBodyPools }] = res;
-    const wallets = JSON.parse(resBodyWallets);
-    const walletCount = wallets ? wallets.length : 0;
-    check(walletCount, {
-        'At least one wallet is required to run the test': (count) => count > 0
-    });
-    console.log(`Wallet addresses configuration file contains ${walletCount} wallets`);
-    if (walletCount < MAX_VU) {
-        console.warn(
-            `Requested VU count: (${MAX_VU}), is greater than the available walled addresses: ${walletCount}. Some addresses will be reused`
-        );
-    }
+  console.log(`Running in ${RUN_MODE} mode`);
+  console.log(`Ramp-up: ${RAMP_UP_DURATION}; Sustain: ${STEADY_STATE_DURATION}; Iteration sleep: ${ITERATION_SLEEP}s`);
+
+  if (RUN_MODE === RunMode.RestoreHD) {
+    console.log('HD wallet params are:', hdWalletParams);
+  }
+
+  const res = http.batch([WALLET_ADDRESSES_URL, POOL_ADDRESSES_URL]);
+  check(res, { 'get wallets and pools files': (r) => r.every(({ status }) => status >= 200 && status < 300) });
+
+  const [{ body: resBodyWallets }, { body: resBodyPools }] = res;
+  const walletsOrig = JSON.parse(resBodyWallets);
+  const walletsOrigCount = walletsOrig ? walletsOrig.length : 0;
+  check(walletsOrigCount, {
+    'At least one wallet is required to run the test': (count) => count > 0
+  });
+  console.log(`Wallet addresses configuration file contains ${walletsOrigCount} addresses`);
+
+  // One wallet, one address
+  let wallets = chunkArray(walletsOrig, 1);
+  if (RUN_MODE === RunMode.RestoreHD) {
+    // One wallet, multiple addresses
+    // Remove "big transaction history wallets"
+    const filteredWallets = walletsOrig.filter(({ tx_count }) => tx_count < hdWalletParams.maxTxHistory);
+    // Create chunks of `activeAddrCount` addresses per HD wallet
+    wallets = chunkArray(filteredWallets, hdWalletParams.activeAddrCount);
+  }
+
+  const requestedAddrCount = RUN_MODE === RunMode.RestoreHD ? MAX_VU * hdWalletParams.activeAddrCount : MAX_VU;
+  const availableAddrCount = wallets.length;
 
-    const poolAddresses = JSON.parse(resBodyPools);
-    check(poolAddresses, {
-        'At least one stake pool address is required to run the test': (p) => p && p.length
-    });
-    return { wallets: wallets.slice(0, MAX_VU), poolAddresses };
+  if (availableAddrCount < requestedAddrCount) {
+    console.warn(
+      `Requested wallet count * addresses per wallet: ${requestedAddrCount}, is greater than the available addresses: ${availableAddrCount}. Some addresses will be reused`
+    );
+  }
+
+  const poolAddresses = JSON.parse(resBodyPools);
+  check(poolAddresses, {
+    'At least one stake pool address is required to run the test': (p) => p && p.length > 0
+  });
+  return { poolAddresses, wallets: wallets.slice(0, MAX_VU) };
 }
 
-/** Keeps track of wallets that were successfully syncd to avoid restoring twice */
+/** Keeps track of wallets that were successfully synced to avoid restoring twice */
 const syncedWallets = new Set();
 
-export let options = {
-    ext: {
-        loadimpact: {
-            distribution: { 'amazon:us:portland': { loadZone: 'amazon:us:portland', percent: 100 } },
-            apm: []
-        }
-    },
-    thresholds: {
-        wallet_sync_count: ['count >= ' + MAX_VU], // All wallets should have syncd
-        // Use https://k6.io/docs/using-k6/thresholds/ to set more thresholds. E.g.:
-        // wallet_sync: ['p(95)<5000'], // 95% of wallets should sync in under 5 seconds
-        wallet_sync: [{ threshold: 'p(95) < 30000', delayAbortEval: '5s' }] // We get a nice graph if we enable thresholds. See this stat on a graph
-    },
-    scenarios: {
-        SyncDifferentSizeWallets: {
-            executor: 'ramping-vus',
-            startVUs: 1,
-            stages: [
-                { duration: RAMP_UP_DURATION, target: MAX_VU },
-                { duration: STEADY_STATE_DURATION, target: MAX_VU }
-            ],
-            gracefulRampDown: '0s',
-            gracefulStop: '0s'
-        }
+export const options = {
+  ext: {
+    loadimpact: {
+      apm: [],
+      distribution: { 'amazon:us:portland': { loadZone: 'amazon:us:portland', percent: 100 } }
+    }
+  },
+  scenarios: {
+    SyncDifferentSizeWallets: {
+      executor: 'ramping-vus',
+      gracefulRampDown: '0s',
+      gracefulStop: '0s',
+      stages: [
+        { duration: RAMP_UP_DURATION, target: MAX_VU },
+        { duration: STEADY_STATE_DURATION, target: MAX_VU }
+      ],
+      startVUs: 1
     }
+  },
+  thresholds: {
+    // All wallets should have syncd
+    // Use https://k6.io/docs/using-k6/thresholds/ to set more thresholds. E.g.:
+    // wallet_sync: ['p(95)<5000'], // 95% of wallets should sync in under 5 seconds
+    wallet_sync: [{ delayAbortEval: '5s', threshold: 'p(95) < 30000' }],
+
+    wallet_sync_count: [`count >= ${MAX_VU}`] // We get a nice graph if we enable thresholds. See this stat on a graph
+  }
 };
 
 /** Util functions for sending the http post requests to cardano-sdk services */
 const cardanoHttpPost = (url, body = {}) => {
-    const options = { headers: { 'content-type': 'application/json' } };
-    return http.post(`${PROVIDER_SERVER_URL}/${url}`, JSON.stringify(body), options);
+  const opts = { headers: { 'content-type': 'application/json' } };
+  return http.post(`${PROVIDER_SERVER_URL}/${url}`, JSON.stringify(body), opts);
 };
-const txsByAddress = (address) => {
+
+/**
+ *
+ * @param addresses Bech32 cardano addresses: `Cardano.Address[]`
+ * @param takeOne  true: query only the first page; false: query until no more pages
+ * @param pageSize Use as request page size. Also, bundle this many addresses on each request.
+ */
+const txsByAddress = (addresses, takeOne = false, pageSize = 25) => {
+  const addressChunks = chunkArray(addresses, pageSize);
+  for (const chunk of addressChunks) {
     let startAt = 0;
-    const pageSize = 25;
     let txCount = 0;
+
     do {
-        const resp = cardanoHttpPost('chain-history/txs/by-addresses', {
-            addresses: [address],
-            blockRange: { lowerBound: { __type: 'undefined' } },
-            pagination: { limit: pageSize, startAt }
-        });
-
-        if (resp.status !== 200) {
-            // No point in trying to get the other pages.
-            // Should we log this? it will show up as if the restoration was quicker since this wallet did not fetch all the pages
-            break;
-        }
-
-        const { pageResults } = JSON.parse(resp.body);
-        startAt += pageSize;
-        txCount = pageResults.length;
-    } while (txCount === pageSize);
+      const resp = cardanoHttpPost('chain-history/txs/by-addresses', {
+        addresses: chunk,
+        blockRange: { lowerBound: { __type: 'undefined' } },
+        pagination: { limit: pageSize, startAt }
+      });
+
+      if (resp.status !== 200) {
+        // No point in trying to get the other pages.
+        // Should we log this? it will show up as if the restoration was quicker since this wallet did not fetch all the pages
+        break;
+      }
+
+      const { pageResults } = JSON.parse(resp.body);
+      startAt += pageSize;
+      txCount = pageResults.length;
+    } while (txCount === pageSize && !takeOne);
+  }
 };
-const utxosByAddresses = (address) => cardanoHttpPost('utxo/utxo-by-addresses', { addresses: [address] });
-const rewardsAccBalance = (rewardAccount) =>
-    cardanoHttpPost('rewards/account-balance', { rewardAccount: rewardAccount });
+
+const utxosByAddresses = (addresses) => {
+  const addressChunks = chunkArray(addresses, 25);
+  for (const chunk of addressChunks) {
+    cardanoHttpPost('utxo/utxo-by-addresses', { addresses: chunk });
+  }
+};
+
+const rewardsAccBalance = (rewardAccount) => cardanoHttpPost('rewards/account-balance', { rewardAccount });
 const stakePoolSearch = (poolAddress) =>
-    cardanoHttpPost('stake-pool/search', {
-        filters: { identifier: { values: [{ id: poolAddress }] } },
-        pagination: { limit: 1, startAt: 0 }
-    });
+  cardanoHttpPost('stake-pool/search', {
+    filters: { identifier: { values: [{ id: poolAddress }] } },
+    pagination: { limit: 1, startAt: 0 }
+  });
+
+/**
+ * Changes the last 3 chars. Checksum will be broken but I assume it is not verified
+ * Avoiding to import keyagent here to generate actual addresses as it would be difficult to do it
+ * in K6 cloud.
+ */
+const getDummyAddr = (addr, idx, suffix = 'mh') => {
+  const last3Chars = addr.slice(-3);
+  const updateChars = last3Chars !== `${suffix}${idx}` ? `${suffix}${idx}` : `${idx}${suffix}`;
+  return addr.slice(0, -3) + updateChars;
+};
+
+/**
+ * Simulate http requests normally done in discovery mode.
+ * `wallet` MUST have at least 2 elements
+ */
+const walletDiscovery = (wallet) => {
+  check(wallet, {
+    'At least one address is required to run HD wallet discovery mode': (walletArray) =>
+      walletArray && walletArray.length > 0
+  });
+
+  console.debug(`Start walletDiscovery for ${wallet.length} addresses`);
+
+  // Discover stake keys derived at index > 0 on the first payment key
+  // We don't expect to find anything here so we'll use dummy addresses
+  console.debug('Discover stake keys on payment #0');
+  for (let i = 0; i < hdWalletParams.stakeAddrSearchGap; i++) {
+    const addr = getDummyAddr(wallet[0].address, i);
+    txsByAddress([addr], true, 1);
+  }
+
+  // Discover active payment addresses
+  console.debug('Discover payment addresses #1+');
+  for (const { address } of wallet) {
+    // Even if txByAddresses accepts multiple addresses, discovery does it one by one
+    txsByAddress([address], true, 1);
+  }
+
+  // Discover calls in payment address gap
+  console.debug('Discover in search gap');
+  for (let i = 0; i < hdWalletParams.paymentAddrSearchGap; i++) {
+    const addr = getDummyAddr(wallet[0].address, i, 'hm');
+    txsByAddress([addr], true, 1);
+  }
+};
 
 /** Simulation of requests performed by a wallet while restoring */
 const syncWallet = ({ wallet, poolAddress }) => {
-    const startTime = Date.now();
-    const { address, stake_address: rewardAccount } = wallet;
-    cardanoHttpPost('network-info/era-summaries');
-    cardanoHttpPost('network-info/ledger-tip');
-    txsByAddress(address);
-    utxosByAddresses(address);
-    cardanoHttpPost('network-info/era-summaries');
-    cardanoHttpPost('network-info/genesis-parameters');
-    cardanoHttpPost('network-info/protocol-parameters');
-    rewardsAccBalance(rewardAccount);
-    cardanoHttpPost('network-info/ledger-tip');
-    cardanoHttpPost('network-info/lovelace-supply');
-    cardanoHttpPost('network-info/stake');
-    if (RUN_MODE === RunMode.Restore) {
-        stakePoolSearch(poolAddress);
-    }
-    cardanoHttpPost('stake-pool/stats');
+  const startTime = Date.now();
+  const addresses = wallet.map(({ address }) => address);
+
+  if (RUN_MODE === RunMode.RestoreHD) {
+    walletDiscovery(wallet);
+  }
+
+  cardanoHttpPost('network-info/era-summaries');
+  cardanoHttpPost(TIP_URL);
+  txsByAddress(addresses);
+  utxosByAddresses(addresses);
+  cardanoHttpPost('network-info/era-summaries');
+  cardanoHttpPost('network-info/genesis-parameters');
+  cardanoHttpPost('network-info/protocol-parameters');
+  // Test restoring HD wallets with a single stake key
+  rewardsAccBalance(wallet[0].stake_address);
+  cardanoHttpPost(TIP_URL);
+  cardanoHttpPost('network-info/lovelace-supply');
+  cardanoHttpPost('network-info/stake');
+  if (RUN_MODE === RunMode.Restore) {
+    stakePoolSearch(poolAddress);
+  }
+  cardanoHttpPost('stake-pool/stats');
 
-    syncedWallets.add(wallet.address);
-    walletSyncTrend.add(Date.now() - startTime);
-    walletSyncCount.add(1);
+  // Consider the wallet synced by tracking its first address
+  syncedWallets.add(addresses[0]);
+  walletSyncTrend.add(Date.now() - startTime);
+  walletSyncCount.add(1);
 };
 
 /**
  * Simulate keeping wallet in sync
  * For now, just polling the tip
  */
-const emulateIdleClient = () => cardanoHttpPost('network-info/ledger-tip');
+const emulateIdleClient = () => cardanoHttpPost(TIP_URL);
 
+/**
+ * K6 default VU action function
+ *
+ * wallets: {address: Cardano.Address, stake_address: Cardano.RewardAccount, tx_count: number}[][]
+ * poolAddresses: Cardano.PoolId[]
+ */
 export default function ({ wallets, poolAddresses }) {
-    // Get the wallet for the current virtual user
-    let wallet = wallets[__VU % wallets.length];
-    let poolAddress = poolAddresses[__VU % poolAddresses.length];
+  // Get the wallet for the current virtual user
+  // eslint-disable-next-line no-undef
+  const vu = __VU;
+  const wallet = wallets[vu % wallets.length]; // each wallet is a collection of addresses
+  const poolAddress = poolAddresses[vu % poolAddresses.length];
 
-    syncedWallets.has(wallet.address) ? emulateIdleClient() : syncWallet({ wallet, poolAddress });
-    sleep(ITERATION_SLEEP);
-}
+  syncedWallets.has(wallet[0].address) ? emulateIdleClient() : syncWallet({ poolAddress, wallet });
+  sleep(ITERATION_SLEEP);
+}

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

@@ -1,4 +1,3 @@
-/* eslint-disable max-statements */
 import { AddressType, KeyRole } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import {
@@ -13,24 +12,72 @@ import {
   walletReady,
   walletVariables
 } from '../../src';
+import { containerExec } from 'dockerode-utils';
+import { getRandomPort } from 'get-port-please';
 import { logger } from '@cardano-sdk/util-dev';
+import Docker from 'dockerode';
+import path from 'path';
 
-const env = getEnv(walletVariables);
 const vrf = Cardano.VrfVkHex('2ee5a4c423224bb9c42107fc18a60556d6a83cec1d9dd37a71f56af7198fc759');
 
-const wallet1Params: KeyAgentFactoryProps = {
-  accountIndex: 0,
-  chainId: env.KEY_MANAGEMENT_PARAMS.chainId,
-  mnemonic:
-    // eslint-disable-next-line max-len
-    'phrase raw learn suspect inmate powder combine apology regular hero gain chronic fruit ritual short screen goddess odor keen creek brand today kit machine',
-  passphrase: 'some_passphrase'
-};
-
 describe('cache invalidation', () => {
+  let testProviderServer: Docker.Container;
   let wallet1: TestWallet;
 
   beforeAll(async () => {
+    const port = await getRandomPort();
+
+    // Get environment from original provider server container
+    const docker = new Docker();
+    const originalProviderServer = docker.getContainer('local-network-e2e-provider-server-1');
+    const cmdOutput = await containerExec(originalProviderServer, [
+      'node',
+      '-e',
+      'console.log(`sdk_token${JSON.stringify(process.env)}sdk_token`)'
+    ]);
+    const matchResult = cmdOutput[0].match(/sdk_token(.*)sdk_token/);
+
+    if (!matchResult) throw new Error('Error getting original container environment');
+
+    const [, encodedEnv] = matchResult;
+
+    const Env = Object.entries({
+      ...JSON.parse(encodedEnv),
+      DISABLE_DB_CACHE: 'false',
+      LOGGER_MIN_SEVERITY: 'debug'
+    }).map(([key, value]) => `${key}=${value}`);
+
+    const network = docker.getNetwork('local-network-e2e_default');
+
+    // Test container
+    testProviderServer = await docker.createContainer({
+      Env,
+      HostConfig: {
+        Binds: [`${path.join(__dirname, '..', '..', '..', '..', 'compose', 'placeholder-secrets')}:/run/secrets`],
+        PortBindings: { '3000/tcp': [{ HostPort: port.toString() }] }
+      },
+      Image: 'local-network-e2e-provider-server',
+      name: 'local-network-e2e-provider-server-test'
+    });
+
+    await network.connect({ Container: testProviderServer.id });
+    await testProviderServer.start();
+
+    const override = Object.fromEntries(
+      Object.entries(process.env)
+        .filter(([key]) => walletVariables.includes(key as typeof walletVariables[number]))
+        .map(([key, value]) => [key, value?.replace('localhost:4000/', `localhost:${port}/`)])
+    );
+    const env = getEnv(walletVariables, { override });
+    const wallet1Params: KeyAgentFactoryProps = {
+      accountIndex: 0,
+      chainId: env.KEY_MANAGEMENT_PARAMS.chainId,
+      mnemonic:
+        // eslint-disable-next-line max-len
+        'phrase raw learn suspect inmate powder combine apology regular hero gain chronic fruit ritual short screen goddess odor keen creek brand today kit machine',
+      passphrase: 'some_passphrase'
+    };
+
     jest.setTimeout(180_000);
 
     wallet1 = await getWallet({
@@ -45,9 +92,13 @@ describe('cache invalidation', () => {
     await waitForWalletStateSettle(wallet1.wallet);
   });
 
-  afterAll(() => wallet1.wallet.shutdown());
+  afterAll(async () => {
+    wallet1.wallet.shutdown();
+    await testProviderServer.stop();
+    await testProviderServer.remove();
+  });
 
-  test.skip('cache is invalidated on epoch rollover', async () => {
+  test('cache is invalidated on epoch rollover', async () => {
     const wallet = wallet1.wallet;
 
     await walletReady(wallet);

package/test/providers/HandleProvider.test.ts

@@ -0,0 +1,39 @@
+import { createLogger } from '@cardano-sdk/util-dev';
+import { getEnv, walletVariables } from '../../src';
+import { handleHttpProvider } from '@cardano-sdk/cardano-services-client';
+import fs from 'fs';
+import path from 'path';
+
+const logger = createLogger();
+const env = getEnv(walletVariables);
+
+describe('HandleProvider', () => {
+  it('resolves handle', async () => {
+    const policyPath = path.join(__dirname, '../../local-network/sdk-ipc/handle_policy_ids');
+    const policyId = fs.readFileSync(policyPath, 'utf8').toString().trim();
+    const handleName = 'HelloHandle'; // handle minted in mint-handles.sh
+    const handleName2 = 'TestHandle';
+    const config = { baseUrl: env.HANDLE_PROVIDER_PARAMS.baseUrl, logger };
+    const handleProvider = handleHttpProvider(config);
+    const handle = await handleProvider.resolveHandles({ handles: [handleName, handleName2] });
+    expect(handle.length).toEqual(2);
+    expect(handle[0]?.handle).toEqual('HelloHandle');
+    expect(handle[0]?.hasDatum).toEqual(false);
+    expect(handle[0]?.policyId).toEqual(policyId);
+    expect(handle[0]?.resolvedAt).toBeDefined();
+  });
+
+  it('resolves non existent handle with null', async () => {
+    const config = { baseUrl: env.HANDLE_PROVIDER_PARAMS.baseUrl, logger };
+    const handleProvider = handleHttpProvider(config);
+    const handle = await handleProvider.resolveHandles({ handles: ['nonexistent'] });
+    expect(handle).toEqual([null]);
+  });
+
+  it('allows request an empty list of handles', async () => {
+    const config = { baseUrl: env.HANDLE_PROVIDER_PARAMS.baseUrl, logger };
+    const handleProvider = handleHttpProvider(config);
+    const handle = await handleProvider.resolveHandles({ handles: [] });
+    expect(handle.length).toEqual(0);
+  });
+});