@cardano-sdk/e2e 0.32.8 → 0.33.1

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

@@ -3,11 +3,11 @@
 import * as dotenv from 'dotenv';
 import path from 'path';
 dotenv.config({ path: path.join(__dirname, '../../../.env') });
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano } from '@cardano-sdk/core';
 import { GroupedAddress, util } from '@cardano-sdk/key-management';
 import { Logger } from 'ts-log';
 import { MINUTE, createMockKeyAgent, getEnv, getWallet, waitForWalletStateSettle, walletVariables } from '../../../src';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import { logger } from '@cardano-sdk/util-dev';
 import { mapToGroupedAddress } from '../../artillery/wallet-restoration/WalletRestoration';
 
@@ -34,7 +34,7 @@ const range = (toNum: number) => {
   return resArr;
 };
 
-const initWallets = async (walletsNum: number, addresses: GroupedAddress[]): Promise<PersonalWallet[]> => {
+const initWallets = async (walletsNum: number, addresses: GroupedAddress[]): Promise<BaseWallet[]> => {
   testLogger.info('Number of concurrent users: ', walletsNum);
   let currentAddress;
   const wallets = [];

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

@@ -1,5 +1,5 @@
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano, StakePoolProvider } from '@cardano-sdk/core';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import {
   TestWallet,
   getEnv,
@@ -16,7 +16,7 @@ import { waitForWalletStateSettle } from '../../../wallet/test/util';
 
 const env = getEnv(walletVariables);
 
-const submitDelegationTx = async (wallet: PersonalWallet, pools: Cardano.PoolId[]) => {
+const submitDelegationTx = async (wallet: BaseWallet, pools: Cardano.PoolId[]) => {
   logger.info(`Creating delegation tx at epoch #${(await firstValueFrom(wallet.currentEpoch$)).epochNo}`);
   const { tx: signedTx } = await wallet
     .createTxBuilder()
@@ -33,7 +33,7 @@ const submitDelegationTx = async (wallet: PersonalWallet, pools: Cardano.PoolId[
   return signedTx;
 };
 
-const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: PersonalWallet) => {
+const generateTxs = async (sendingWallet: BaseWallet, receivingWallet: BaseWallet) => {
   logger.info('Sending 100 txs to generate reward fees');
 
   const tAdaToSend = 5_000_000n;
@@ -47,7 +47,7 @@ const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: Perso
   }
 };
 
-const buildSpendRewardTx = async (sendingWallet: PersonalWallet, receivingWallet: PersonalWallet) => {
+const buildSpendRewardTx = async (sendingWallet: BaseWallet, receivingWallet: BaseWallet) => {
   const tAdaToSend = 5_000_000n;
   const [{ address: receivingAddress }] = await firstValueFrom(receivingWallet.addresses$);
   const txBuilder = sendingWallet.createTxBuilder();
@@ -77,8 +77,8 @@ const getPoolIds = async (stakePoolProvider: StakePoolProvider, count: number) =
 
 describe('delegation rewards', () => {
   let providers: TestWallet['providers'];
-  let wallet1: PersonalWallet;
-  let wallet2: PersonalWallet;
+  let wallet1: BaseWallet;
+  let wallet2: BaseWallet;
 
   const initializeWallets = async () => {
     ({ wallet: wallet1, providers } = await getWallet({

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

@@ -1,10 +1,10 @@
 import * as Crypto from '@cardano-sdk/crypto';
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano, EraSummary, StakePoolProvider, createSlotEpochCalc } from '@cardano-sdk/core';
 import { InMemoryKeyAgent, KeyRole } from '@cardano-sdk/key-management';
 import { MultiSigTx } from './MultiSigTx';
 import { MultiSigWallet } from './MultiSigWallet';
 import { Observable, filter, firstValueFrom, map, take } from 'rxjs';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import { TrackerSubject } from '@cardano-sdk/util-rxjs';
 import {
   bip32Ed25519Factory,
@@ -49,7 +49,7 @@ const getPoolIds = async (stakePoolProvider: StakePoolProvider, count: number) =
   return poolIds;
 };
 
-const fundMultiSigWallet = async (sendingWallet: PersonalWallet, address: Cardano.PaymentAddress) => {
+const fundMultiSigWallet = async (sendingWallet: BaseWallet, address: Cardano.PaymentAddress) => {
   logger.info(`Funding multisig wallet with address: ${address}`);
 
   const tAdaToSend = 5_000_000n;
@@ -60,7 +60,7 @@ const fundMultiSigWallet = async (sendingWallet: PersonalWallet, address: Cardan
   await sendingWallet.submitTx(signedTx);
 };
 
-const getKeyAgent = async (mnemonics: string, faucetWallet: PersonalWallet, bip32Ed25519: Crypto.Bip32Ed25519) => {
+const getKeyAgent = async (mnemonics: string, faucetWallet: BaseWallet, bip32Ed25519: Crypto.Bip32Ed25519) => {
   const genesis = await firstValueFrom(faucetWallet.genesisParameters$);
 
   const keyAgent = await createStandaloneKeyAgent(mnemonics.split(' '), genesis, bip32Ed25519);
@@ -70,7 +70,7 @@ const getKeyAgent = async (mnemonics: string, faucetWallet: PersonalWallet, bip3
   return { keyAgent, pubKey };
 };
 
-const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: PersonalWallet) => {
+const generateTxs = async (sendingWallet: BaseWallet, receivingWallet: BaseWallet) => {
   logger.info('Sending 100 txs to generate reward fees');
 
   const tAdaToSend = 5_000_000n;
@@ -86,7 +86,7 @@ const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: Perso
 
 const createMultiSignWallet = async (
   keyAgent: InMemoryKeyAgent,
-  faucetWallet: PersonalWallet,
+  faucetWallet: BaseWallet,
   participants: Array<Crypto.Ed25519PublicKeyHex>
 ) => {
   const props = {
@@ -117,7 +117,7 @@ const getTxConfirmationEpoch = async (
 };
 
 describe('multi signature wallet', () => {
-  let faucetWallet: PersonalWallet;
+  let faucetWallet: BaseWallet;
   let aliceKeyAgent: InMemoryKeyAgent;
   let bobKeyAgent: InMemoryKeyAgent;
   let charlotteKeyAgent: InMemoryKeyAgent;

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

@@ -0,0 +1,199 @@
+import { BaseWallet } from '@cardano-sdk/wallet';
+import { Cardano, StakePoolProvider } from '@cardano-sdk/core';
+import { buildSharedWallets } from '../wallet/SharedWallet/ultils';
+import { filter, firstValueFrom, map, take } from 'rxjs';
+import {
+  getEnv,
+  getTxConfirmationEpoch,
+  getWallet,
+  runningAgainstLocalNetwork,
+  submitAndConfirm,
+  waitForEpoch,
+  walletReady,
+  walletVariables
+} from '../../src';
+import { isNotNil } from '@cardano-sdk/util';
+import { logger } from '@cardano-sdk/util-dev';
+import { waitForWalletStateSettle } from '../../../wallet/test/util';
+
+const env = getEnv(walletVariables);
+
+const submitDelegationTx = async (alice: BaseWallet, bob: BaseWallet, charlotte: BaseWallet, pool: Cardano.PoolId) => {
+  logger.info(`Creating delegation tx at epoch #${(await firstValueFrom(alice.currentEpoch$)).epochNo}`);
+  let tx = (await alice.createTxBuilder().delegateFirstStakeCredential(pool).build().sign()).tx;
+
+  tx = await bob.updateWitness({ sender: { id: 'e2e' }, tx });
+  tx = await charlotte.updateWitness({ sender: { id: 'e2e' }, tx });
+  await alice.submitTx(tx);
+
+  const { epochNo } = await firstValueFrom(alice.currentEpoch$);
+  logger.info(`Delegation tx ${tx.id} submitted at epoch #${epochNo}`);
+
+  return tx;
+};
+
+const generateTxs = async (sendingWallet: BaseWallet, receivingWallet: BaseWallet) => {
+  logger.info('Sending 100 txs to generate reward fees');
+
+  const tAdaToSend = 5_000_000n;
+  const [{ address: receivingAddress }] = await firstValueFrom(receivingWallet.addresses$);
+
+  for (let i = 0; i < 100; i++) {
+    const txBuilder = sendingWallet.createTxBuilder();
+    const txOut = await txBuilder.buildOutput().address(receivingAddress).coin(tAdaToSend).build();
+    const { tx: signedTx } = await txBuilder.addOutput(txOut).build().sign();
+    await sendingWallet.submitTx(signedTx);
+  }
+};
+
+const buildSpendRewardTx = async (
+  alice: BaseWallet,
+  bob: BaseWallet,
+  charlotte: BaseWallet,
+  receivingWallet: BaseWallet
+) => {
+  const tAdaToSend = 5_000_000n;
+  const [{ address: receivingAddress }] = await firstValueFrom(receivingWallet.addresses$);
+  const txBuilder = alice.createTxBuilder();
+  const txOut = await txBuilder.buildOutput().address(receivingAddress).coin(tAdaToSend).build();
+  const tx = txBuilder.addOutput(txOut).build();
+
+  const { body } = await tx.inspect();
+  logger.debug('Body of tx before sign');
+  logger.debug(body);
+  let signedTx = (await tx.sign()).tx;
+
+  signedTx = await bob.updateWitness({ sender: { id: 'e2e' }, tx: signedTx });
+  signedTx = await charlotte.updateWitness({ sender: { id: 'e2e' }, tx: signedTx });
+
+  logger.debug('Body of tx after sign');
+  logger.debug(signedTx.body);
+
+  return signedTx;
+};
+
+const getPoolIds = async (stakePoolProvider: StakePoolProvider, count: number) => {
+  const activePools = await stakePoolProvider.queryStakePools({
+    filters: { pledgeMet: true, status: [Cardano.StakePoolStatus.Active] },
+    pagination: { limit: count, startAt: 0 }
+  });
+  expect(activePools.totalResultCount).toBeGreaterThanOrEqual(count);
+  const poolIds = activePools.pageResults.map(({ id }) => id);
+  expect(poolIds.every((poolId) => poolId !== undefined)).toBeTruthy();
+  logger.info('Wallet funds will be staked to pools:', poolIds);
+  return poolIds;
+};
+
+describe('delegation rewards', () => {
+  let fundingTx: Cardano.Tx<Cardano.TxBody>;
+  let faucetWallet: BaseWallet;
+  let faucetAddress: Cardano.PaymentAddress;
+  let aliceMultiSigWallet: BaseWallet;
+  let bobMultiSigWallet: BaseWallet;
+  let charlotteMultiSigWallet: BaseWallet;
+  let stakePoolProvider: StakePoolProvider;
+
+  const initialFunds = 10_000_000n;
+
+  beforeAll(async () => {
+    jest.setTimeout(180_000);
+
+    ({
+      wallet: faucetWallet,
+      providers: { stakePoolProvider }
+    } = await getWallet({ env, logger, name: 'Sending Wallet', polling: { interval: 50 } }));
+
+    // Make sure the wallet has sufficient funds to run this test
+    await walletReady(faucetWallet, initialFunds);
+
+    faucetAddress = (await firstValueFrom(faucetWallet.addresses$))[0].address;
+
+    ({ aliceMultiSigWallet, bobMultiSigWallet, charlotteMultiSigWallet } = await buildSharedWallets(
+      env,
+      await firstValueFrom(faucetWallet.genesisParameters$),
+      logger
+    ));
+
+    await Promise.all([
+      waitForWalletStateSettle(aliceMultiSigWallet),
+      waitForWalletStateSettle(bobMultiSigWallet),
+      waitForWalletStateSettle(charlotteMultiSigWallet)
+    ]);
+
+    const [{ address: receivingAddress }] = await firstValueFrom(aliceMultiSigWallet.addresses$);
+
+    logger.info(`Address ${faucetAddress} will send ${initialFunds} lovelace to address ${receivingAddress}.`);
+
+    // Send 10 tADA to the shared wallet.
+    const txBuilder = faucetWallet.createTxBuilder();
+    const txOutput = await txBuilder.buildOutput().address(receivingAddress).coin(initialFunds).build();
+    fundingTx = (await txBuilder.addOutput(txOutput).build().sign()).tx;
+    await faucetWallet.submitTx(fundingTx);
+
+    logger.info(
+      `Submitted transaction id: ${fundingTx.id}, inputs: ${JSON.stringify(
+        fundingTx.body.inputs.map((txIn) => [txIn.txId, txIn.index])
+      )} and outputs:${JSON.stringify(
+        fundingTx.body.outputs.map((txOut) => [txOut.address, Number.parseInt(txOut.value.coins.toString())])
+      )}.`
+    );
+  });
+
+  afterAll(() => {
+    faucetWallet.shutdown();
+    aliceMultiSigWallet.shutdown();
+    bobMultiSigWallet.shutdown();
+    charlotteMultiSigWallet.shutdown();
+    faucetWallet.shutdown();
+  });
+
+  it('will receive rewards for delegated tADA and can spend them', async () => {
+    if (!(await runningAgainstLocalNetwork())) {
+      return logger.fatal(
+        "Skipping test 'will receive rewards for delegated tADA' as it should only run with a fast test network"
+      );
+    }
+
+    const txFoundInHistory = await firstValueFrom(
+      aliceMultiSigWallet.transactions.history$.pipe(
+        map((txs) => txs.find((tx) => tx.id === fundingTx.id)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(txFoundInHistory?.id).toEqual(fundingTx.id);
+
+    // Arrange
+    const [poolId] = await getPoolIds(stakePoolProvider, 1);
+
+    // Stake and wait for reward
+    const signedTx = await submitDelegationTx(aliceMultiSigWallet, bobMultiSigWallet, charlotteMultiSigWallet, poolId);
+
+    const delegationTxConfirmedAtEpoch = await getTxConfirmationEpoch(aliceMultiSigWallet, signedTx);
+
+    logger.info(`Delegation tx confirmed at epoch #${delegationTxConfirmedAtEpoch}`);
+
+    await waitForEpoch(aliceMultiSigWallet, delegationTxConfirmedAtEpoch + 2);
+
+    await generateTxs(faucetWallet, aliceMultiSigWallet);
+    await waitForEpoch(aliceMultiSigWallet, delegationTxConfirmedAtEpoch + 4);
+
+    // Check reward
+    await waitForWalletStateSettle(aliceMultiSigWallet);
+    const rewards = await firstValueFrom(aliceMultiSigWallet.balance.rewardAccounts.rewards$);
+    expect(rewards).toBeGreaterThan(0n);
+
+    logger.info(`Generated rewards: ${rewards} tLovelace`);
+
+    // Spend reward
+    const spendRewardTx = await buildSpendRewardTx(
+      aliceMultiSigWallet,
+      bobMultiSigWallet,
+      charlotteMultiSigWallet,
+      faucetWallet
+    );
+    expect(spendRewardTx.body.withdrawals?.length).toBeGreaterThan(0);
+    await submitAndConfirm(aliceMultiSigWallet, spendRewardTx);
+  });
+});

package/test/wallet/PersonalWallet/byron.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano } from '@cardano-sdk/core';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { filter, firstValueFrom, map, take } from 'rxjs';
 import { getEnv, walletVariables } from '../../../src/environment';
@@ -11,7 +11,7 @@ const env = getEnv(walletVariables);
 const logger = createLogger();
 
 describe('PersonalWallet/byron', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
 
   beforeAll(async () => {
     wallet = (await getWallet({ env, idx: 0, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;

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

@@ -1,8 +1,8 @@
 /* eslint-disable max-statements */
 import * as Crypto from '@cardano-sdk/crypto';
+import { BaseWallet, ObservableWallet } from '@cardano-sdk/wallet';
 import { BigIntMath } from '@cardano-sdk/util';
 import { Cardano } from '@cardano-sdk/core';
-import { ObservableWallet, PersonalWallet } from '@cardano-sdk/wallet';
 import {
   TX_TIMEOUT_DEFAULT,
   TestWallet,
@@ -33,7 +33,7 @@ const getWalletStateSnapshot = async (wallet: ObservableWallet) => {
   return {
     balance: { available: balanceAvailable, deposit, total: balanceTotal },
     epoch: epoch.epochNo,
-    isStakeKeyRegistered: rewardAccount.keyStatus === Cardano.StakeKeyStatus.Registered,
+    isStakeKeyRegistered: rewardAccount.credentialStatus === Cardano.StakeCredentialStatus.Registered,
     publicStakeKey,
     rewardAccount,
     rewardsBalance,
@@ -73,7 +73,7 @@ describe('PersonalWallet/delegation', () => {
     wallet2.wallet.shutdown();
   });
 
-  const chooseWallets = async (): Promise<[PersonalWallet, PersonalWallet]> => {
+  const chooseWallets = async (): Promise<[BaseWallet, BaseWallet]> => {
     const wallet1Balance = await firstValueFrom(wallet1.wallet.balance.utxo.available$);
     const wallet2Balance = await firstValueFrom(wallet2.wallet.balance.utxo.available$);
     return wallet1Balance.coins > wallet2Balance.coins
@@ -171,7 +171,7 @@ describe('PersonalWallet/delegation', () => {
 
     const stakeKeyHash = await bip32Ed25519.getPubKeyHash(tx1ConfirmedState.publicStakeKey.publicStakeKey);
     expect(stakeKeyHash).toEqual(Cardano.RewardAccount.toHash(tx1ConfirmedState.rewardAccount.address));
-    expect(tx1ConfirmedState.publicStakeKey.keyStatus).toBe(Cardano.StakeKeyStatus.Registered);
+    expect(tx1ConfirmedState.publicStakeKey.credentialStatus).toBe(Cardano.StakeCredentialStatus.Registered);
 
     // Make a 2nd tx with key de-registration
     const { tx: txDeregisterSigned } = await sourceWallet.createTxBuilder().delegatePortfolio(null).build().sign();
@@ -181,7 +181,7 @@ describe('PersonalWallet/delegation', () => {
 
     // No longer delegating
     expect(tx2ConfirmedState.rewardAccount.delegatee?.nextNextEpoch?.id).toBeUndefined();
-    expect(tx2ConfirmedState.publicStakeKey.keyStatus).toBe(Cardano.StakeKeyStatus.Unregistered);
+    expect(tx2ConfirmedState.publicStakeKey.credentialStatus).toBe(Cardano.StakeCredentialStatus.Unregistered);
 
     // Deposit is returned to wallet balance
     const expectedCoinsAfterTx2 = expectedCoinsAfterTx1 + stakeKeyDeposit - txDeregisterSigned.body.fee;

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

@@ -1,5 +1,5 @@
+import { BaseWallet, DelegatedStake, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
 import { Cardano } from '@cardano-sdk/core';
-import { DelegatedStake, PersonalWallet, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
 import { MINUTE, firstValueFromTimed, getWallet, submitAndConfirm, walletReady } from '../../../src';
 import { Observable, filter, firstValueFrom, map, tap } from 'rxjs';
 import { Percent } from '@cardano-sdk/util';
@@ -13,7 +13,7 @@ const POOLS_COUNT = 5;
 const distributionMessage = 'ObservableWallet.delegation.distribution$:';
 
 /** Distribute the wallet funds evenly across all its addresses */
-const fundWallet = async (wallet: PersonalWallet) => {
+const fundWallet = async (wallet: BaseWallet) => {
   await walletReady(wallet, 0n);
   const addresses = await firstValueFrom(wallet.addresses$);
 
@@ -42,13 +42,13 @@ const fundWallet = 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.StakeCredentialStatus[],
   timeout = MINUTE
 ) =>
   firstValueFromTimed(
     rewardAccounts$.pipe(
-      tap((accts) => accts.map(({ address, keyStatus }) => logger.debug(address, keyStatus))),
-      map((accts) => accts.map(({ keyStatus }) => keyStatus)),
+      tap((accts) => accts.map(({ address, credentialStatus }) => logger.debug(address, credentialStatus))),
+      map((accts) => accts.map(({ credentialStatus }) => credentialStatus)),
       filter((statusArr) => statusArr.every((s) => statuses.includes(s)))
     ),
     `Timeout waiting for all reward accounts stake keys to be one of ${statuses.join('|')}`,
@@ -56,12 +56,12 @@ const rewardAccountStatuses = async (
   );
 
 /** Create stakeKey deregistration transaction for all reward accounts */
-const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> => {
+const deregisterAllStakeKeys = async (wallet: BaseWallet): Promise<void> => {
   await walletReady(wallet, 0n);
   try {
     await rewardAccountStatuses(
       wallet.delegation.rewardAccounts$,
-      [Cardano.StakeKeyStatus.Unregistered, Cardano.StakeKeyStatus.Unregistering],
+      [Cardano.StakeCredentialStatus.Unregistered, Cardano.StakeCredentialStatus.Unregistering],
       0
     );
     logger.info('Stake keys are already deregistered');
@@ -73,14 +73,14 @@ const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> =>
     await submitAndConfirm(wallet, deregTx);
 
     await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
-      Cardano.StakeKeyStatus.Unregistered,
-      Cardano.StakeKeyStatus.Unregistering
+      Cardano.StakeCredentialStatus.Unregistered,
+      Cardano.StakeCredentialStatus.Unregistering
     ]);
     logger.info('Deregistered all stake keys');
   }
 };
 
-const getPoolIds = async (wallet: PersonalWallet): Promise<Cardano.StakePool[]> => {
+const getPoolIds = async (wallet: BaseWallet): Promise<Cardano.StakePool[]> => {
   const activePools = await wallet.stakePoolProvider.queryStakePools({
     filters: { status: [Cardano.StakePoolStatus.Active] },
     pagination: { limit: POOLS_COUNT, startAt: 0 }
@@ -91,7 +91,7 @@ const getPoolIds = async (wallet: PersonalWallet): Promise<Cardano.StakePool[]>
 
 /** Delegate to unique POOLS_COUNT pools. Use even distribution as default. */
 const delegateToMultiplePools = async (
-  wallet: PersonalWallet,
+  wallet: BaseWallet,
   weights = Array.from({ length: POOLS_COUNT }).map(() => 1)
 ) => {
   const poolIds = await getPoolIds(wallet);
@@ -106,7 +106,7 @@ const delegateToMultiplePools = async (
   return { poolIds, portfolio };
 };
 
-const delegateAllToSinglePool = async (wallet: PersonalWallet): Promise<void> => {
+const delegateAllToSinglePool = async (wallet: BaseWallet): 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);
@@ -122,7 +122,7 @@ const delegateAllToSinglePool = async (wallet: PersonalWallet): Promise<void> =>
 };
 
 describe('PersonalWallet/delegationDistribution', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
 
   beforeAll(async () => {
     wallet = (await getWallet({ env, idx: 3, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;
@@ -153,8 +153,8 @@ describe('PersonalWallet/delegationDistribution', () => {
     // Check that reward addresses were delegated
     await walletReady(wallet);
     await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
-      Cardano.StakeKeyStatus.Registering,
-      Cardano.StakeKeyStatus.Registered
+      Cardano.StakeCredentialStatus.Registering,
+      Cardano.StakeCredentialStatus.Registered
     ]);
     logger.debug('Delegations successfully done');
 

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

@@ -1,7 +1,7 @@
 /* eslint-disable sonarjs/no-duplicate-string */
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano, metadatum } from '@cardano-sdk/core';
 import { KeyAgent, TransactionSigner } from '@cardano-sdk/key-management';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import {
   bip32Ed25519Factory,
   burnTokens,
@@ -33,9 +33,9 @@ const toHex = (value: string) =>
     .join('');
 
 describe('Ada handle', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
   let keyAgent: KeyAgent;
-  let receivingWallet: PersonalWallet;
+  let receivingWallet: BaseWallet;
   let policySigner: TransactionSigner;
   let policyId: Cardano.PolicyId;
   let policyScript: Cardano.NativeScript;
@@ -123,7 +123,7 @@ describe('Ada handle', () => {
   });
 
   // eslint-disable-next-line max-statements
-  it("PersonalWallet discovers it's own cip25 and cip68 handles", async () => {
+  it("BaseWallet discovers it's own cip25 and cip68 handles", async () => {
     await mintCIP25andCIP68Handles(wallet, keyAgent, policyId);
     let utxo = await firstValueFrom(wallet.balance.utxo.available$);
     let receivingUtxo = await firstValueFrom(receivingWallet.balance.utxo.available$);

package/test/wallet/PersonalWallet/metadata.test.ts

@@ -1,5 +1,5 @@
+import { BaseWallet, createWalletUtil } from '@cardano-sdk/wallet';
 import { Cardano } from '@cardano-sdk/core';
-import { PersonalWallet, createWalletUtil } from '@cardano-sdk/wallet';
 import { filter, firstValueFrom, map } from 'rxjs';
 import { getEnv, getWallet, walletReady, walletVariables } from '../../../src';
 import { isNotNil } from '@cardano-sdk/util';
@@ -8,7 +8,7 @@ import { logger } from '@cardano-sdk/util-dev';
 const env = getEnv(walletVariables);
 
 describe('PersonalWallet/metadata', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
   let ownAddress: Cardano.PaymentAddress;
 
   beforeAll(async () => {

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

@@ -1,5 +1,5 @@
+import { BaseWallet, FinalizeTxProps } from '@cardano-sdk/wallet';
 import { Cardano, nativeScriptPolicyId } from '@cardano-sdk/core';
-import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
@@ -20,7 +20,7 @@ const env = getEnv(walletVariables);
 const logger = createLogger();
 
 describe('PersonalWallet/mint', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
 
   afterAll(() => {
     wallet.shutdown();
@@ -79,14 +79,20 @@ describe('PersonalWallet/mint', () => {
           }
         }
       ]),
-      witness: { extraSigners: [alicePolicySigner], scripts: [policyScript] }
+      signingOptions: {
+        extraSigners: [alicePolicySigner]
+      },
+      witness: { scripts: [policyScript] }
     };
 
     const unsignedTx = await wallet.initializeTx(txProps);
 
     const finalizeProps: FinalizeTxProps = {
+      signingOptions: {
+        extraSigners: [alicePolicySigner]
+      },
       tx: unsignedTx,
-      witness: { extraSigners: [alicePolicySigner], scripts: [policyScript] }
+      witness: { scripts: [policyScript] }
     };
 
     const signedTx = await wallet.finalizeTx(finalizeProps);

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

@@ -1,5 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import { AddressType, GroupedAddress, util } from '@cardano-sdk/key-management';
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano } from '@cardano-sdk/core';
 import {
   KeyAgentFactoryProps,
@@ -10,7 +11,6 @@ import {
   normalizeTxBody,
   walletReady
 } from '../../../src';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { filter, map, take } from 'rxjs';
 import { getEnv, walletVariables } from '../../../src/environment';
@@ -23,7 +23,7 @@ const PAYMENT_ADDRESSES_TO_GENERATE = PAYMENT_INDICES_TO_GENERATE * 2; // Extern
 const COINS_PER_ADDRESS = 3_000_000n;
 
 describe('PersonalWallet/multiAddress', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
 
   beforeAll(async () => {
     wallet = (await getWallet({ env, idx: 0, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;

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

@@ -1,6 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
+import { BaseWallet, FinalizeTxProps } from '@cardano-sdk/wallet';
 import { Cardano, nativeScriptPolicyId } from '@cardano-sdk/core';
-import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
@@ -20,7 +20,7 @@ const env = getEnv(walletVariables);
 const logger = createLogger();
 
 describe('PersonalWallet/multisignature', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
   const assetName = '3030303030';
 
   afterAll(() => {
@@ -100,14 +100,20 @@ describe('PersonalWallet/multisignature', () => {
           }
         }
       ]),
-      witness: { extraSigners: [alicePolicySigner, bobPolicySigner], scripts: [policyScript] }
+      signingOptions: {
+        extraSigners: [alicePolicySigner, bobPolicySigner]
+      },
+      witness: { scripts: [policyScript] }
     };
 
     const unsignedTx = await wallet.initializeTx(txProps);
 
     const finalizeProps: FinalizeTxProps = {
+      signingOptions: {
+        extraSigners: [alicePolicySigner, bobPolicySigner]
+      },
       tx: unsignedTx,
-      witness: { extraSigners: [alicePolicySigner, bobPolicySigner], scripts: [policyScript] }
+      witness: { scripts: [policyScript] }
     };
 
     const signedTx = await wallet.finalizeTx(finalizeProps);