@cardano-sdk/e2e 0.45.4 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.45.4",
+  "version": "0.47.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "repository": "https://github.com/input-output-hk/cardano-js-sdk",
   "license": "Apache-2.0",
@@ -23,7 +23,6 @@
     "load-test-custom:wallet-restoration": "ts-node test/load-test-custom/wallet-restoration/wallet-restoration.test.ts",
     "test": "echo 'test' command not implemented yet",
     "test:blockfrost": "jest -c jest.config.js --forceExit --selectProjects blockfrost --runInBand --verbose",
-    "test:blockfrost:providers": "jest -c jest.config.js --forceExit --selectProjects blockfrost-providers --runInBand --verbose",
     "test:utils": "jest -c jest.config.js --forceExit --selectProjects utils --verbose",
     "test:long-running": "jest -c jest.config.js --forceExit --selectProjects long-running --runInBand --verbose",
     "test:local-network": "jest -c jest.config.js --forceExit --selectProjects local-network --runInBand --verbose",
@@ -76,20 +75,20 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^7.1.4",
     "@cardano-ogmios/client": "6.9.0",
-    "@cardano-sdk/cardano-services": "~0.32.3",
-    "@cardano-sdk/cardano-services-client": "~0.22.3",
-    "@cardano-sdk/core": "~0.41.4",
-    "@cardano-sdk/crypto": "~0.1.31",
-    "@cardano-sdk/hardware-ledger": "~0.12.13",
-    "@cardano-sdk/hardware-trezor": "~0.6.12",
-    "@cardano-sdk/input-selection": "~0.13.28",
-    "@cardano-sdk/key-management": "~0.24.10",
-    "@cardano-sdk/ogmios": "~0.18.13",
-    "@cardano-sdk/tx-construction": "~0.21.13",
+    "@cardano-sdk/cardano-services": "~0.33.1",
+    "@cardano-sdk/cardano-services-client": "~0.23.1",
+    "@cardano-sdk/core": "~0.42.0",
+    "@cardano-sdk/crypto": "~0.1.32",
+    "@cardano-sdk/hardware-ledger": "~0.12.15",
+    "@cardano-sdk/hardware-trezor": "~0.6.14",
+    "@cardano-sdk/input-selection": "~0.13.30",
+    "@cardano-sdk/key-management": "~0.24.12",
+    "@cardano-sdk/ogmios": "~0.18.15",
+    "@cardano-sdk/tx-construction": "~0.22.0",
     "@cardano-sdk/util": "~0.15.5",
-    "@cardano-sdk/util-dev": "~0.23.13",
-    "@cardano-sdk/util-rxjs": "~0.7.41",
-    "@cardano-sdk/wallet": "~0.44.22",
+    "@cardano-sdk/util-dev": "~0.24.0",
+    "@cardano-sdk/util-rxjs": "~0.7.43",
+    "@cardano-sdk/wallet": "~0.45.0",
     "@dcspark/cardano-multiplatform-lib-nodejs": "^3.1.1",
     "@shiroyasha9/axios-fetch-adapter": "1.0.3",
     "axios": "^1.7.4",
@@ -119,10 +118,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.12.44",
-    "@cardano-sdk/projection": "~0.12.13",
-    "@cardano-sdk/projection-typeorm": "~0.9.13",
-    "@cardano-sdk/web-extension": "~0.34.21",
+    "@cardano-sdk/dapp-connector": "~0.12.46",
+    "@cardano-sdk/projection": "~0.12.15",
+    "@cardano-sdk/projection-typeorm": "~0.9.15",
+    "@cardano-sdk/web-extension": "~0.34.23",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -182,5 +181,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f9d460a3fd97481bfb2fa5719a838b3521283907"
+  "gitHead": "cfb81dc2bf655e0a4d433b7c13a2aaa494510444"
 }

package/src/environment.ts

@@ -92,6 +92,8 @@ const validators = {
   TEST_CLIENT_ASSET_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_CHAIN_HISTORY_PROVIDER: str(),
   TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS: providerParams(),
+  TEST_CLIENT_DREP_PROVIDER: str({ choices: ['blockfrost'] }),
+  TEST_CLIENT_DREP_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_HANDLE_PROVIDER: str(),
   TEST_CLIENT_HANDLE_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_NETWORK_INFO_PROVIDER: str(),
@@ -145,6 +147,8 @@ export const walletVariables = [
   'TEST_CLIENT_ASSET_PROVIDER_PARAMS',
   'TEST_CLIENT_CHAIN_HISTORY_PROVIDER',
   'TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS',
+  'TEST_CLIENT_DREP_PROVIDER',
+  'TEST_CLIENT_DREP_PROVIDER_PARAMS',
   'TEST_CLIENT_HANDLE_PROVIDER',
   'TEST_CLIENT_HANDLE_PROVIDER_PARAMS',
   'KEY_MANAGEMENT_PARAMS',

package/src/factories.ts

@@ -18,6 +18,7 @@ import {
   AssetProvider,
   Cardano,
   ChainHistoryProvider,
+  DRepProvider,
   HandleProvider,
   NetworkInfoProvider,
   ProviderFactory,
@@ -37,7 +38,13 @@ import {
 } from '@cardano-sdk/key-management';
 import {
   BlockfrostAssetProvider,
+  BlockfrostChainHistoryProvider,
   BlockfrostClient,
+  BlockfrostDRepProvider,
+  BlockfrostNetworkInfoProvider,
+  BlockfrostRewardsProvider,
+  BlockfrostTxSubmitProvider,
+  BlockfrostUtxoProvider,
   CardanoWsClient,
   assetInfoHttpProvider,
   chainHistoryHttpProvider,
@@ -76,6 +83,7 @@ export type CreateKeyAgent = (dependencies: KeyAgentDependencies) => Promise<Asy
 export const keyManagementFactory = new ProviderFactory<CreateKeyAgent>();
 export const assetProviderFactory = new ProviderFactory<AssetProvider>();
 export const chainHistoryProviderFactory = new ProviderFactory<ChainHistoryProvider>();
+export const drepProviderFactory = new ProviderFactory<DRepProvider>();
 export const networkInfoProviderFactory = new ProviderFactory<NetworkInfoProvider>();
 export const rewardsProviderFactory = new ProviderFactory<RewardsProvider>();
 export const txSubmitProviderFactory = new ProviderFactory<TxSubmitProvider>();
@@ -162,6 +170,33 @@ chainHistoryProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).chainHistoryProvider
 );
 
+chainHistoryProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostChainHistoryProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostChainHistoryProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        await networkInfoProviderFactory.create('blockfrost', params, logger),
+        logger
+      )
+    );
+  });
+});
+
+drepProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger): Promise<DRepProvider> => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostDRepProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise<DRepProvider>(async (resolve) => {
+    resolve(
+      new BlockfrostDRepProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 networkInfoProviderFactory.register(
   HTTP_PROVIDER,
   async (params: any, logger: Logger): Promise<NetworkInfoProvider> => {
@@ -178,6 +213,19 @@ networkInfoProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).networkInfoProvider
 );
 
+networkInfoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostNetworkInfoProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostNetworkInfoProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 rewardsProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<RewardsProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${rewardsHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -186,6 +234,19 @@ rewardsProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logge
   });
 });
 
+rewardsProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostRewardsProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostRewardsProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 txSubmitProviderFactory.register(OGMIOS_PROVIDER, async (params: any, logger: Logger): Promise<TxSubmitProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${NodeTxSubmitProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -220,6 +281,19 @@ txSubmitProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logg
   });
 });
 
+txSubmitProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostTxSubmitProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostTxSubmitProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 utxoProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<UtxoProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${utxoHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -233,6 +307,19 @@ utxoProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).utxoProvider
 );
 
+utxoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostUtxoProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostUtxoProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 handleProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<HandleProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${handleHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -412,6 +499,11 @@ export const getWallet = async (props: GetWalletProps) => {
       env.TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS,
       logger
     ),
+    drepProvider: await drepProviderFactory.create(
+      env.TEST_CLIENT_DREP_PROVIDER,
+      env.TEST_CLIENT_DREP_PROVIDER_PARAMS,
+      logger
+    ),
     handleProvider: await handleProviderFactory.create(
       env.TEST_CLIENT_HANDLE_PROVIDER,
       env.TEST_CLIENT_HANDLE_PROVIDER_PARAMS,
@@ -500,6 +592,11 @@ export const getSharedWallet = async (props: GetSharedWalletProps) => {
       env.TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS,
       logger
     ),
+    drepProvider: await drepProviderFactory.create(
+      env.TEST_CLIENT_DREP_PROVIDER,
+      env.TEST_CLIENT_DREP_PROVIDER_PARAMS,
+      logger
+    ),
     handleProvider: await handleProviderFactory.create(
       env.TEST_CLIENT_HANDLE_PROVIDER,
       env.TEST_CLIENT_HANDLE_PROVIDER_PARAMS,

package/src/scripts/generate-dotenv.sh

@@ -40,6 +40,9 @@ TEST_CLIENT_ASSET_PROVIDER=http
 TEST_CLIENT_ASSET_PROVIDER_PARAMS='{\"baseUrl\":\"${url}\"}'
 TEST_CLIENT_CHAIN_HISTORY_PROVIDER=ws
 TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS='{\"baseUrl\":\"${url}\"}'
+TEST_CLIENT_DREP_PROVIDER: 'blockfrost'
+# TODO: use blockfrost URL
+TEST_CLIENT_DREP_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:3015"}'
 TEST_CLIENT_HANDLE_PROVIDER=http
 TEST_CLIENT_HANDLE_PROVIDER_PARAMS='{\"baseUrl\":\"${url}\"}'
 TEST_CLIENT_NETWORK_INFO_PROVIDER=ws

package/test/blockfrost/queryTransactions.test.ts

@@ -1,18 +1,13 @@
-import { BlockfrostChainHistoryProvider, BlockfrostNetworkInfoProvider, util } from '@cardano-sdk/cardano-services';
+import { BlockfrostChainHistoryProvider, BlockfrostNetworkInfoProvider } from '@cardano-sdk/cardano-services-client';
 import { Cardano, ChainHistoryProvider } from '@cardano-sdk/core';
 import { logger } from '@cardano-sdk/util-dev';
+import { util } from '@cardano-sdk/cardano-services';
 
 describe.only('BlockfrostChainHistoryProvider', () => {
   let chainHistoryProvider: ChainHistoryProvider;
-  let blockfrost;
   beforeAll(async () => {
-    blockfrost = util.getBlockfrostApi();
-    const networkInfoProvider = new BlockfrostNetworkInfoProvider({ blockfrost, logger });
-    chainHistoryProvider = new BlockfrostChainHistoryProvider({
-      blockfrost,
-      logger,
-      networkInfoProvider
-    });
+    const networkInfoProvider = new BlockfrostNetworkInfoProvider(util.getBlockfrostClient(), logger);
+    chainHistoryProvider = new BlockfrostChainHistoryProvider(util.getBlockfrostClient(), networkInfoProvider, logger);
   });
 
   describe('transactionsByHashes', () => {

package/test/load-test-custom/wallet-init/wallet-init.test.ts

@@ -16,6 +16,7 @@ import {
   assetProviderFactory,
   bip32Ed25519Factory,
   chainHistoryProviderFactory,
+  drepProviderFactory,
   getEnv,
   getLoadTestScheduler,
   keyManagementFactory,
@@ -55,6 +56,11 @@ const getProviders = async () => ({
     env.TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS,
     logger
   ),
+  drepProvider: await drepProviderFactory.create(
+    env.TEST_CLIENT_DREP_PROVIDER,
+    env.TEST_CLIENT_DREP_PROVIDER_PARAMS,
+    logger
+  ),
   networkInfoProvider: await networkInfoProviderFactory.create(
     env.TEST_CLIENT_NETWORK_INFO_PROVIDER,
     env.TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS,

package/test/wallet_epoch_0/PersonalWallet/multiAddress.test.ts

@@ -139,6 +139,7 @@ describe('PersonalWallet/multiAddress', () => {
     expect(returnAdaTxFoundInHistory.id).toEqual(returnAdaSignedTx.id);
     expect(normalizeTxBody(returnAdaTxFoundInHistory.body)).toEqual(normalizeTxBody(returnAdaSignedTx.body));
 
+    await walletReady(newWallet.wallet);
     const endingBalance = await firstValueFromTimed(newWallet.wallet.balance.utxo.total$);
     const expectedEndingBalance = 1_500_000n - returnAdaTxFoundInHistory.body.fee;
 

package/test/wallet_epoch_3/PersonalWallet/drepRetirement.test.ts

@@ -0,0 +1,296 @@
+/* eslint-disable unicorn/consistent-destructuring */
+
+import * as Crypto from '@cardano-sdk/crypto';
+import { BaseWallet } from '@cardano-sdk/wallet';
+import { Cardano, setInConwayEra } from '@cardano-sdk/core';
+import { logger } from '@cardano-sdk/util-dev';
+
+import { filter, firstValueFrom, map } from 'rxjs';
+import {
+  firstValueFromTimed,
+  getEnv,
+  getWallet,
+  submitAndConfirm,
+  unDelegateWallet,
+  waitForWalletStateSettle,
+  walletReady,
+  walletVariables
+} from '../../../src';
+
+/*
+Test that rewardAccounts$ drepDelegatees are updated when dreps retire, provided one of the following conditions are met:
+  - a transaction build is attempted
+  - drepDelegatees change, new ones are added, old ones removed
+Both of these actions trigger a refetch for all dreps found in drepDelegatees.
+
+Setup:
+  - create three accounts (wallet, drepWallet, drepWallet2)
+  - drep* wallets register as dreps
+  - wallet delegates to 2 stake pools, resulting in 2 registered stake keys
+  - wallet delegates voting power: stakeKey1 & stakeKey2 to drepWallet & drepWallet2 respectively
+    - Expect to see DRep1 & DRep2 in drepDelegatees
+  - DRep1 retires - no change in drepDelegatees because a refresh was not triggered
+  - Build a transaction with wallet, but do not submit
+    - Expect to see DRep1 removed from drepDelegatees
+  - DRep2 retires - no change in drepDelegatees because a refresh was not triggered
+  - Using another instance of the wallet, delegate stakeKey1 to AlwaysAbstain
+    - Original wallet detects the change of delegatees according to tx history, which triggers a refetch for all dreps
+    - Expect DRep2 to be removed from drepDelegatees
+*/
+
+const { CertificateType, CredentialType, RewardAccount, StakePoolStatus } = Cardano;
+
+const env = getEnv(walletVariables);
+
+const anchor = {
+  dataHash: '3e33018e8293d319ef5b3ac72366dd28006bd315b715f7e7cfcbd3004129b80d' as Crypto.Hash32ByteBase16,
+  url: 'https://testing.this'
+};
+
+const getTestWallet = async (idx: number, name: string, minCoinBalance?: bigint) => {
+  const { wallet } = await getWallet({ env, idx, logger, name, polling: { interval: 50 } });
+
+  await walletReady(wallet, minCoinBalance);
+
+  return wallet;
+};
+
+describe('PersonalWallet/drepRetirement', () => {
+  let dRepWallet1: BaseWallet;
+  let dRepWallet2: BaseWallet;
+  let delegatingWallet: BaseWallet;
+
+  let dRepCredential1: Cardano.Credential & { type: Cardano.CredentialType.KeyHash };
+  let drepId1: Cardano.DRepID;
+  let dRepCredential2: Cardano.Credential & { type: Cardano.CredentialType.KeyHash };
+  let drepId2: Cardano.DRepID;
+  let poolId1: Cardano.PoolId;
+  let poolId2: Cardano.PoolId;
+  let stakeCredential1: Cardano.Credential;
+  let stakeCredential2: Cardano.Credential;
+
+  let dRepDeposit: bigint;
+
+  const getDRepCredential = async (wallet: BaseWallet) => {
+    const drepPubKey = await wallet.governance.getPubDRepKey();
+    const dRepKeyHash = Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(
+      (await Crypto.Ed25519PublicKey.fromHex(drepPubKey!).hash()).hex()
+    );
+
+    return { hash: dRepKeyHash, type: CredentialType.KeyHash } as typeof dRepCredential1;
+  };
+
+  const getDeposits = async () => {
+    const protocolParameters = await delegatingWallet.networkInfoProvider.protocolParameters();
+
+    return [
+      BigInt(protocolParameters.dRepDeposit!),
+      BigInt(protocolParameters.governanceActionDeposit!),
+      BigInt(protocolParameters.stakeKeyDeposit)
+    ];
+  };
+
+  const getPoolIds = async () => {
+    const activePools = await delegatingWallet.stakePoolProvider.queryStakePools({
+      filters: { status: [StakePoolStatus.Active] },
+      pagination: { limit: 2, startAt: 0 }
+    });
+
+    return activePools.pageResults.map(({ id }) => id);
+  };
+
+  const getStakeCredential = async () => {
+    const rewardAccounts = await firstValueFrom(
+      delegatingWallet.addresses$.pipe(map((addresses) => addresses.map(({ rewardAccount }) => rewardAccount)))
+    );
+
+    return rewardAccounts.map((rewardAccount) => ({
+      hash: Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(RewardAccount.toHash(rewardAccount)),
+      type: CredentialType.KeyHash
+    }));
+  };
+
+  const feedDRepWallet = async (dRepWallet: BaseWallet, amount: bigint) => {
+    const balance = await firstValueFrom(dRepWallet.balance.utxo.total$);
+
+    if (balance.coins > amount) return;
+
+    const address = await firstValueFrom(dRepWallet.addresses$.pipe(map((addresses) => addresses[0].address)));
+
+    const signedTx = await delegatingWallet
+      .createTxBuilder()
+      .addOutput({ address, value: { coins: amount } })
+      .build()
+      .sign();
+
+    await submitAndConfirm(delegatingWallet, signedTx.tx, 1);
+  };
+
+  const sendDRepRegCert = async (dRepWallet: BaseWallet, register: boolean) => {
+    const dRepCredential = await getDRepCredential(dRepWallet);
+    const common = { dRepCredential, deposit: dRepDeposit };
+    const dRepUnRegCert: Cardano.UnRegisterDelegateRepresentativeCertificate = {
+      __typename: CertificateType.UnregisterDelegateRepresentative,
+      ...common
+    };
+    const dRepRegCert: Cardano.RegisterDelegateRepresentativeCertificate = {
+      __typename: CertificateType.RegisterDelegateRepresentative,
+      anchor,
+      ...common
+    };
+    const certificate = register ? dRepRegCert : dRepUnRegCert;
+    const signedTx = await dRepWallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [certificate] }))
+      .build()
+      .sign();
+    await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+  };
+
+  const isRegisteredDRep = async (wallet: BaseWallet) => {
+    await waitForWalletStateSettle(wallet);
+    return await firstValueFrom(wallet.governance.isRegisteredAsDRep$);
+  };
+
+  beforeAll(async () => {
+    // TODO: remove once mainnet hardforks to conway-era, and this becomes "the norm"
+    setInConwayEra(true);
+
+    [delegatingWallet, dRepWallet1, dRepWallet2] = await Promise.all([
+      getTestWallet(0, 'wallet-delegating', 100_000_000n),
+      getTestWallet(1, 'wallet-DRep1', 0n),
+      getTestWallet(2, 'wallet-DRep2', 0n)
+    ]);
+
+    [dRepCredential1, dRepCredential2, [dRepDeposit], [poolId1, poolId2]] = await Promise.all([
+      getDRepCredential(dRepWallet1),
+      getDRepCredential(dRepWallet2),
+      getDeposits(),
+      getPoolIds()
+    ]);
+
+    drepId1 = Cardano.DRepID.cip129FromCredential(dRepCredential1);
+    drepId2 = Cardano.DRepID.cip129FromCredential(dRepCredential2);
+
+    await feedDRepWallet(dRepWallet1, dRepDeposit * 2n);
+    await feedDRepWallet(dRepWallet2, dRepDeposit * 2n);
+
+    if (!(await isRegisteredDRep(dRepWallet1))) await sendDRepRegCert(dRepWallet1, true);
+    if (!(await isRegisteredDRep(dRepWallet2))) await sendDRepRegCert(dRepWallet2, true);
+
+    const txBuilder = delegatingWallet.createTxBuilder().delegatePortfolio({
+      name: 'Test Portfolio',
+      pools: [
+        { id: Cardano.PoolIdHex(Cardano.PoolId.toKeyHash(poolId1)), weight: 1 },
+        { id: Cardano.PoolIdHex(Cardano.PoolId.toKeyHash(poolId2)), weight: 1 }
+      ]
+    });
+    const poolDelegationTx = await txBuilder.build().sign();
+    await submitAndConfirm(delegatingWallet, poolDelegationTx.tx, 1);
+
+    [stakeCredential1, stakeCredential2] = await getStakeCredential();
+  });
+
+  afterAll(async () => {
+    if (await isRegisteredDRep(dRepWallet1)) await sendDRepRegCert(dRepWallet1, false);
+    if (await isRegisteredDRep(dRepWallet2)) await sendDRepRegCert(dRepWallet2, false);
+    await unDelegateWallet(delegatingWallet);
+
+    delegatingWallet.shutdown();
+    dRepWallet1.shutdown();
+    dRepWallet2.shutdown();
+
+    // TODO: remove once mainnet hardforks to conway-era, and this becomes "the norm"
+    setInConwayEra(false);
+  });
+
+  it('emits drepDelegatees after delegating voting power', async () => {
+    const voteDelegCert1: Cardano.VoteDelegationCertificate = {
+      __typename: CertificateType.VoteDelegation,
+      dRep: dRepCredential1,
+      stakeCredential: stakeCredential1
+    };
+    const voteDelegCert2: Cardano.VoteDelegationCertificate = {
+      __typename: CertificateType.VoteDelegation,
+      dRep: dRepCredential2,
+      stakeCredential: stakeCredential2
+    };
+
+    const signedTx = await delegatingWallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [voteDelegCert1, voteDelegCert2] }))
+      .build()
+      .sign();
+    await submitAndConfirm(delegatingWallet, signedTx.tx, 1);
+
+    const drepDelegatees = await firstValueFrom(
+      delegatingWallet.delegation.rewardAccounts$.pipe(
+        map((accounts) => accounts.map(({ dRepDelegatee }) => dRepDelegatee))
+      )
+    );
+
+    expect(drepDelegatees).toEqual([
+      { delegateRepresentative: expect.objectContaining({ active: true, id: drepId1 }) },
+      { delegateRepresentative: expect.objectContaining({ active: true, id: drepId2 }) }
+    ]);
+  });
+
+  it('transaction build triggers detection of retired DRep', async () => {
+    // Retire DRep1
+    await sendDRepRegCert(dRepWallet1, false);
+
+    // Only build and inspect to trigger the refetch of drep infos
+    await delegatingWallet.createTxBuilder().delegatePortfolio(null).build().inspect();
+
+    const drepDelegatees = await firstValueFrom(
+      delegatingWallet.delegation.rewardAccounts$.pipe(
+        map((accounts) => accounts.map(({ dRepDelegatee }) => dRepDelegatee))
+      )
+    );
+
+    expect(drepDelegatees).toEqual([
+      { delegateRepresentative: expect.objectContaining({ active: false, id: drepId1 }) },
+      { delegateRepresentative: expect.objectContaining({ active: true, amount: 0n, hasScript: false, id: drepId2 }) }
+    ]);
+  });
+
+  it('tx history vote delegation change triggers refresh of all delegations', async () => {
+    // Retire DRep2
+    await sendDRepRegCert(dRepWallet2, false);
+
+    // Create a clone of the delegatingWallet and change drep delegation.
+    // The delegatingWallet tx history will update, which will trigger a refetch of all dreps, including DRep2 which was retired.
+    const delegatingWalletClone = await getTestWallet(0, 'wallet-delegating-clone', 0n);
+    const signedTx = await delegatingWalletClone
+      .createTxBuilder()
+      .customize(({ txBody }) => ({
+        ...txBody,
+        certificates: [
+          {
+            __typename: CertificateType.VoteDelegation,
+            dRep: { __typename: 'AlwaysAbstain' },
+            stakeCredential: stakeCredential1
+          } as Cardano.VoteDelegationCertificate
+        ]
+      }))
+      .build()
+      .sign();
+    await submitAndConfirm(delegatingWalletClone, signedTx.tx, 1);
+
+    const drepDelegatees = await firstValueFromTimed(
+      delegatingWallet.delegation.rewardAccounts$.pipe(
+        map((accounts) => accounts.map(({ dRepDelegatee }) => dRepDelegatee)),
+        filter(
+          ([firstDelegatee]) =>
+            !!firstDelegatee?.delegateRepresentative &&
+            Cardano.isDRepAlwaysAbstain(firstDelegatee.delegateRepresentative)
+        )
+      )
+    );
+
+    expect(drepDelegatees).toEqual([
+      { delegateRepresentative: { __typename: 'AlwaysAbstain' } },
+      { delegateRepresentative: expect.objectContaining({ active: false, amount: 0n, hasScript: false, id: drepId2 }) }
+    ]);
+  });
+});

package/test/blockfrost-providers/networkInfo.test.ts

@@ -1,26 +0,0 @@
-// cSpell:ignore cardano utxos
-
-import { NetworkInfoProvider } from '@cardano-sdk/core';
-import { logger } from '@cardano-sdk/util-dev';
-import { networkInfoHttpProvider } from '@cardano-sdk/cardano-services-client';
-import { toSerializableObject } from '@cardano-sdk/util';
-
-// LW-11858 to enable this
-describe.skip('Web Socket', () => {
-  const legacyProvider = networkInfoHttpProvider({ baseUrl: 'http://localhost:4000/', logger });
-  const provider = networkInfoHttpProvider({ baseUrl: 'http://localhost:4001/', logger });
-
-  const methods: (keyof NetworkInfoProvider)[] = [
-    'eraSummaries',
-    'genesisParameters',
-    'lovelaceSupply',
-    'protocolParameters',
-    'stake'
-  ];
-
-  test.each(methods)('compare %s', async (method) => {
-    const [legacyResponse, response] = await Promise.all([legacyProvider[method](), provider[method]()]);
-
-    expect(toSerializableObject(response)).toEqual(toSerializableObject(legacyResponse));
-  });
-});