@cardano-sdk/e2e 0.32.8 → 0.33.0

package/test/wallet/PersonalWallet/nft.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import { Asset, Cardano, metadatum, nativeScriptPolicyId } from '@cardano-sdk/core';
-import { Assets, FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
+import { Assets, BaseWallet, FinalizeTxProps } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, TransactionSigner, util } from '@cardano-sdk/key-management';
 import {
@@ -21,7 +21,7 @@ const env = getEnv(walletVariables);
 const logger = createLogger();
 
 // Returns [assets in wallet balance, assetInfos with nftMetadata for the assets in the balance]
-const walletBalanceAssetsAndNfts = (wallet: PersonalWallet) =>
+const walletBalanceAssetsAndNfts = (wallet: BaseWallet) =>
   combineLatest([wallet.balance.utxo.total$, wallet.assetInfo$]).pipe(
     filter(([balance]) => !!balance.assets),
     map(([balance, assetInfos]): [Cardano.TokenMap, Assets] => [balance.assets!, assetInfos]),
@@ -41,7 +41,7 @@ describe('PersonalWallet.assets/nft', () => {
   const TOKEN_METADATA_2_INDEX = 1;
   const TOKEN_BURN_INDEX = 2;
 
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
   let policySigner: TransactionSigner;
   let policyId: Cardano.PolicyId;
   let policyScript: Cardano.NativeScript;
@@ -160,15 +160,21 @@ describe('PersonalWallet.assets/nft', () => {
           }
         }
       ]),
-      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+      signingOptions: {
+        extraSigners: [policySigner]
+      },
+      witness: { scripts: [policyScript] }
     };
 
     const unsignedTx = await wallet.initializeTx(txProps);
 
     const finalizeProps: FinalizeTxProps = {
       auxiliaryData,
+      signingOptions: {
+        extraSigners: [policySigner]
+      },
       tx: unsignedTx,
-      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+      witness: { scripts: [policyScript] }
     };
 
     const signedTx = await wallet.finalizeTx(finalizeProps);
@@ -270,14 +276,20 @@ describe('PersonalWallet.assets/nft', () => {
           }
         }
       ]),
-      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+      signingOptions: {
+        extraSigners: [policySigner]
+      },
+      witness: { scripts: [policyScript] }
     };
 
     const unsignedTx = await wallet.initializeTx(txProps);
 
     const finalizeProps: FinalizeTxProps = {
+      signingOptions: {
+        extraSigners: [policySigner]
+      },
       tx: unsignedTx,
-      witness: { extraSigners: [policySigner], scripts: [policyScript] }
+      witness: { scripts: [policyScript] }
     };
 
     const signedTx = await wallet.finalizeTx(finalizeProps);
@@ -334,15 +346,21 @@ describe('PersonalWallet.assets/nft', () => {
               }
             }
           ]),
-          witness: { extraSigners: [policySigner], scripts: [policyScript] }
+          signingOptions: {
+            extraSigners: [policySigner]
+          },
+          witness: { scripts: [policyScript] }
         };
 
         const unsignedTx = await wallet.initializeTx(txProps);
 
         const finalizeProps: FinalizeTxProps = {
           auxiliaryData,
+          signingOptions: {
+            extraSigners: [policySigner]
+          },
           tx: unsignedTx,
-          witness: { extraSigners: [policySigner], scripts: [policyScript] }
+          witness: { scripts: [policyScript] }
         };
 
         const signedTx = await wallet.finalizeTx(finalizeProps);

package/test/wallet/PersonalWallet/phase2validation.test.ts

@@ -1,5 +1,5 @@
+import { BaseWallet, FinalizeTxProps, TransactionFailure } from '@cardano-sdk/wallet';
 import { Cardano, Serialization } from '@cardano-sdk/core';
-import { FinalizeTxProps, PersonalWallet, TransactionFailure } from '@cardano-sdk/wallet';
 import { Hash32ByteBase16 } from '@cardano-sdk/crypto';
 import { HexBlob, isNotNil } from '@cardano-sdk/util';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
@@ -16,7 +16,7 @@ const logger = createLogger();
  * @param wallet The wallet which will set the collateral.
  */
 const createCollateral = async (
-  wallet: PersonalWallet
+  wallet: BaseWallet
 ): Promise<{ collateralInput: Cardano.TxIn; collateralCoinValue: bigint }> => {
   const txBuilder = wallet.createTxBuilder();
 
@@ -53,7 +53,7 @@ const createCollateral = async (
 };
 
 describe('PersonalWallet/phase2validation', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
 
   afterAll(() => {
     wallet.shutdown();
@@ -150,6 +150,6 @@ describe('PersonalWallet/phase2validation', () => {
     expect([TransactionFailure.Phase2Validation, TransactionFailure.FailedToSubmit].includes(failedTx.reason)).toBe(
       true
     );
-    expect(txFoundInHistory.body.fee).toEqual(collateralCoinValue);
+    expect(txFoundInHistory.body.totalCollateral).toEqual(collateralCoinValue);
   });
 });

package/test/wallet/PersonalWallet/pouchDbWalletStores.test.ts

@@ -14,7 +14,7 @@ describe('PersonalWallet/pouchDbWalletStores', () => {
     stores1 = storage.createPouchDbWalletStores(walletName, { logger });
   });
 
-  it('stores and restores PersonalWallet, continues sync after initial load', async () => {
+  it('stores and restores BaseWallet, continues sync after initial load', async () => {
     const wallet1 = (await getWallet({ env, logger, name: 'Test Wallet', stores: stores1 })).wallet;
 
     // wallet1 fetched all responses from wallet provider

package/test/wallet/PersonalWallet/txChainHistory.test.ts

@@ -1,5 +1,5 @@
+import { BaseWallet } from '@cardano-sdk/wallet';
 import { Cardano, CardanoNodeUtil, ProviderError } from '@cardano-sdk/core';
-import { PersonalWallet } from '@cardano-sdk/wallet';
 import { filter, firstValueFrom, map, take } from 'rxjs';
 import { getEnv, getWallet, normalizeTxBody, 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/txChainHistory', () => {
-  let wallet: PersonalWallet;
+  let wallet: BaseWallet;
   let signedTx: Cardano.Tx<Cardano.TxBody>;
 
   beforeEach(async () => {
@@ -61,7 +61,8 @@ describe('PersonalWallet/txChainHistory', () => {
     expect(normalizeTxBody(txFoundInHistory.body)).toEqual(normalizeTxBody(signedTx.body));
   });
 
-  it('can detect a ValueNotConserved error', async () => {
+  // TODO LW-9972
+  it.skip('can detect a ValueNotConserved error', async () => {
     expect.assertions(1);
     // Search chain history to see if the transaction is there.
     await firstValueFrom(

package/test/wallet/PersonalWallet/unspendableUtxos.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sonarjs/no-duplicate-string */
-import { PersonalWallet, utxoEquals } from '@cardano-sdk/wallet';
+import { BaseWallet, utxoEquals } from '@cardano-sdk/wallet';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { filter, firstValueFrom, map, take } from 'rxjs';
 import { firstValueFromTimed, getEnv, getWallet, walletReady, walletVariables } from '../../../src';
@@ -9,8 +9,8 @@ const env = getEnv(walletVariables);
 const logger = createLogger();
 
 describe('PersonalWallet/unspendableUtxos', () => {
-  let wallet1: PersonalWallet;
-  let wallet2: PersonalWallet;
+  let wallet1: BaseWallet;
+  let wallet2: BaseWallet;
 
   afterAll(() => {
     wallet1.shutdown();

package/test/wallet/SharedWallet/delegation.test.ts

@@ -0,0 +1,245 @@
+/* eslint-disable max-statements */
+import { BaseWallet, ObservableWallet } from '@cardano-sdk/wallet';
+import { BigIntMath, isNotNil } from '@cardano-sdk/util';
+import { Cardano, StakePoolProvider } from '@cardano-sdk/core';
+import {
+  TX_TIMEOUT_DEFAULT,
+  firstValueFromTimed,
+  getEnv,
+  getWallet,
+  normalizeTxBody,
+  waitForWalletStateSettle,
+  walletReady,
+  walletVariables
+} from '../../../src';
+import { buildSharedWallets } from './ultils';
+import { combineLatest, filter, firstValueFrom, map, take } from 'rxjs';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv(walletVariables);
+
+const getWalletStateSnapshot = async (wallet: ObservableWallet) => {
+  const [rewardAccount] = await firstValueFrom(wallet.delegation.rewardAccounts$);
+  const [publicStakeKey] = await firstValueFrom(wallet.publicStakeKeys$);
+  const balanceAvailable = await firstValueFrom(wallet.balance.utxo.available$);
+  const balanceTotal = await firstValueFrom(wallet.balance.utxo.total$);
+  const deposit = await firstValueFrom(wallet.balance.rewardAccounts.deposit$);
+  const epoch = await firstValueFrom(wallet.currentEpoch$);
+  const utxoTotal = await firstValueFrom(wallet.utxo.total$);
+  const utxoAvailable = await firstValueFrom(wallet.utxo.available$);
+  const rewardsBalance = await firstValueFrom(wallet.balance.rewardAccounts.rewards$);
+
+  return {
+    balance: { available: balanceAvailable, deposit, total: balanceTotal },
+    epoch: epoch.epochNo,
+    isStakeCredentialRegistered: rewardAccount.credentialStatus === Cardano.StakeCredentialStatus.Registered,
+    publicStakeKey,
+    rewardAccount,
+    rewardsBalance,
+    utxo: { available: utxoTotal, total: utxoAvailable }
+  };
+};
+
+const waitForTx = async (wallet: ObservableWallet, hash: Cardano.TransactionId) => {
+  await firstValueFromTimed(
+    combineLatest([
+      wallet.transactions.history$.pipe(filter((txs) => txs.some(({ id }) => id === hash))),
+      // test that onChain$ works
+      wallet.transactions.outgoing.onChain$.pipe(filter(({ id }) => id === hash))
+    ]),
+    'Tx not found on-chain for too long',
+    TX_TIMEOUT_DEFAULT
+  );
+  await waitForWalletStateSettle(wallet);
+};
+
+describe('SharedWallet/delegation', () => {
+  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();
+  });
+
+  const chooseDifferentPoolIdRandomly = async (delegateeBefore1stTx?: Cardano.PoolId): Promise<Cardano.PoolId> => {
+    const activePools = await stakePoolProvider.queryStakePools({
+      filters: { status: [Cardano.StakePoolStatus.Active] },
+      pagination: { limit: 2, startAt: 0 }
+    });
+    const filteredPools = activePools.pageResults.filter(({ id }) => id !== delegateeBefore1stTx);
+    return filteredPools[Math.round(Math.random() * (filteredPools.length - 1))]?.id;
+  };
+
+  test('delegation preconditions', async () => {
+    const addresses = await firstValueFrom(aliceMultiSigWallet.addresses$);
+    const currentEpoch = await firstValueFrom(aliceMultiSigWallet.currentEpoch$);
+    expect(addresses[0].rewardAccount).toBeTruthy();
+    expect(currentEpoch.epochNo).toBeGreaterThan(0);
+  });
+
+  test('balance & transaction', async () => {
+    const txFoundInHistory = await firstValueFrom(
+      aliceMultiSigWallet.transactions.history$.pipe(
+        map((txs) => txs.find((tx) => tx.id === fundingTx.id)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    logger.info(`Found transaction id in chain history: ${txFoundInHistory.id}`);
+
+    expect(txFoundInHistory).toBeDefined();
+    expect(txFoundInHistory.id).toEqual(fundingTx.id);
+    expect(normalizeTxBody(txFoundInHistory.body)).toEqual(normalizeTxBody(fundingTx.body));
+
+    const tx1OutputCoins = 1_000_000n;
+    await walletReady(aliceMultiSigWallet, tx1OutputCoins);
+
+    const protocolParameters = await firstValueFrom(aliceMultiSigWallet.protocolParameters$);
+    const stakeKeyDeposit = BigInt(protocolParameters.stakeKeyDeposit);
+    const initialState = await getWalletStateSnapshot(aliceMultiSigWallet);
+    expect(initialState.balance.total.coins).toBe(initialState.balance.available.coins);
+    const poolId = await chooseDifferentPoolIdRandomly(initialState.rewardAccount.delegatee?.nextNextEpoch?.id);
+    expect(poolId).toBeDefined();
+    const initialDeposit = initialState.isStakeCredentialRegistered ? stakeKeyDeposit : 0n;
+    expect(initialState.balance.deposit).toBe(initialDeposit);
+
+    // Make a 1st tx with key registration (if not already registered) and stake delegation
+    // Also send some coin to another wallet
+    const destAddresses = (await firstValueFrom(faucetWallet.addresses$))[0].address;
+    const txBuilder = aliceMultiSigWallet.createTxBuilder();
+
+    let tx = (
+      await txBuilder
+        .addOutput(await txBuilder.buildOutput().address(destAddresses).coin(tx1OutputCoins).build())
+        .delegateFirstStakeCredential(poolId)
+        .build()
+        .sign()
+    ).tx;
+
+    tx = await bobMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+    tx = await charlotteMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+    await aliceMultiSigWallet.submitTx(tx);
+
+    // Test it locks available balance after tx is submitted
+    await firstValueFromTimed(
+      aliceMultiSigWallet.transactions.outgoing.inFlight$.pipe(filter((inFlight) => inFlight.length === 1)),
+      'No tx in flight'
+    );
+
+    const tx1PendingState = await getWalletStateSnapshot(aliceMultiSigWallet);
+
+    // Updates total and available balance right after tx is submitted
+    const coinsSpentOnDeposit = initialState.isStakeCredentialRegistered ? 0n : stakeKeyDeposit;
+    const newRewardsWhileSigningAndSubmitting = tx1PendingState.rewardsBalance;
+    const expectedCoinsAfterTx1 =
+      initialState.balance.total.coins -
+      tx1OutputCoins -
+      tx.body.fee -
+      coinsSpentOnDeposit +
+      BigIntMath.sum(tx.body.withdrawals?.map((wd) => wd.quantity) || []) +
+      newRewardsWhileSigningAndSubmitting;
+    expect(tx1PendingState.balance.total.coins).toEqual(expectedCoinsAfterTx1);
+    expect(tx1PendingState.balance.available.coins).toEqual(expectedCoinsAfterTx1);
+    expect(tx1PendingState.balance.deposit).toEqual(stakeKeyDeposit);
+
+    await waitForTx(aliceMultiSigWallet, tx.id);
+    const tx1ConfirmedState = await getWalletStateSnapshot(aliceMultiSigWallet);
+
+    // Updates total and available balance after tx is on-chain
+    expect(tx1ConfirmedState.balance.total.coins).toBe(expectedCoinsAfterTx1);
+    expect(tx1ConfirmedState.balance.total).toEqual(tx1ConfirmedState.balance.available);
+    expect(tx1PendingState.balance.deposit).toEqual(stakeKeyDeposit);
+
+    // If less than two epochs have elapsed, delegatee will still delegate to former pool during current epoch
+    // if more than two epochs has elapsed, delegatee will delegate to new pool.
+    if (tx1ConfirmedState.epoch - initialState.epoch < 2) {
+      expect(tx1ConfirmedState.rewardAccount.delegatee?.currentEpoch?.id).toEqual(
+        initialState?.rewardAccount.delegatee?.currentEpoch?.id
+      );
+      expect(tx1ConfirmedState.rewardAccount.delegatee?.nextEpoch?.id).toEqual(
+        initialState?.rewardAccount.delegatee?.nextEpoch?.id
+      );
+      expect(tx1ConfirmedState.rewardAccount.delegatee?.nextNextEpoch?.id).toEqual(poolId);
+    } else {
+      expect(tx1ConfirmedState.rewardAccount.delegatee?.currentEpoch?.id).toEqual(poolId);
+    }
+
+    expect(tx1ConfirmedState.rewardAccount.credentialStatus).toBe(Cardano.StakeCredentialStatus.Registered);
+
+    // Make a 2nd tx with key de-registration
+    tx = (await aliceMultiSigWallet.createTxBuilder().delegateFirstStakeCredential(null).build().sign()).tx;
+    tx = await bobMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+    tx = await charlotteMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+
+    await aliceMultiSigWallet.submitTx(tx);
+
+    await waitForTx(aliceMultiSigWallet, tx.id);
+    const tx2ConfirmedState = await getWalletStateSnapshot(aliceMultiSigWallet);
+
+    // No longer delegating
+    expect(tx2ConfirmedState.rewardAccount.delegatee?.nextNextEpoch?.id).toBeUndefined();
+    expect(tx2ConfirmedState.rewardAccount.credentialStatus).toBe(Cardano.StakeCredentialStatus.Unregistered);
+
+    // Deposit is returned to wallet balance
+    const expectedCoinsAfterTx2 = expectedCoinsAfterTx1 + stakeKeyDeposit - tx.body.fee;
+    expect(tx2ConfirmedState.balance.total.coins).toBe(expectedCoinsAfterTx2);
+    expect(tx2ConfirmedState.balance.total).toEqual(tx2ConfirmedState.balance.available);
+    expect(tx2ConfirmedState.balance.deposit).toBe(0n);
+  });
+});

package/test/wallet/SharedWallet/simpleTx.test.ts

@@ -0,0 +1,123 @@
+import { BaseWallet } from '@cardano-sdk/wallet';
+import { Cardano } from '@cardano-sdk/core';
+import { buildSharedWallets } from './ultils';
+import { filter, firstValueFrom, map, take } from 'rxjs';
+import {
+  getEnv,
+  getWallet,
+  normalizeTxBody,
+  waitForWalletStateSettle,
+  walletReady,
+  walletVariables
+} from '../../../src';
+import { isNotNil } from '@cardano-sdk/util';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv(walletVariables);
+
+describe('SharedWallet/simpleTx', () => {
+  let fundingTx: Cardano.Tx<Cardano.TxBody>;
+  let faucetWallet: BaseWallet;
+  let faucetAddress: Cardano.PaymentAddress;
+  let aliceMultiSigWallet: BaseWallet;
+  let bobMultiSigWallet: BaseWallet;
+  let charlotteMultiSigWallet: BaseWallet;
+  const initialFunds = 10_000_000n;
+
+  beforeAll(async () => {
+    ({ wallet: faucetWallet } = 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(() => {
+    aliceMultiSigWallet.shutdown();
+    bobMultiSigWallet.shutdown();
+    charlotteMultiSigWallet.shutdown();
+    faucetWallet.shutdown();
+  });
+
+  it('submit a transaction and find it in chain history', async () => {
+    const txFoundInHistory = await firstValueFrom(
+      aliceMultiSigWallet.transactions.history$.pipe(
+        map((txs) => txs.find((tx) => tx.id === fundingTx.id)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    logger.info(`Found transaction id in chain history: ${txFoundInHistory.id}`);
+
+    expect(txFoundInHistory).toBeDefined();
+    expect(txFoundInHistory.id).toEqual(fundingTx.id);
+    expect(normalizeTxBody(txFoundInHistory.body)).toEqual(normalizeTxBody(fundingTx.body));
+
+    const aliceAddress = (await firstValueFrom(aliceMultiSigWallet.addresses$))[0].address;
+    const bobAddress = (await firstValueFrom(bobMultiSigWallet.addresses$))[0].address;
+    const charlotteAddress = (await firstValueFrom(charlotteMultiSigWallet.addresses$))[0].address;
+
+    expect(aliceAddress).toEqual(bobAddress);
+    expect(aliceAddress).toEqual(charlotteAddress);
+
+    // Lets send ada from the shared wallet to the faucet wallet
+
+    // Alice will initiate the transaction.
+    const txBuilder = aliceMultiSigWallet.createTxBuilder();
+    const txOut = await txBuilder.buildOutput().address(faucetAddress).coin(1_000_000n).build();
+    let tx = (await txBuilder.addOutput(txOut).build().sign()).tx;
+
+    // Bob updates the transaction with his witness
+    tx = await bobMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+
+    // Charlotte updates the transaction with her witness
+    tx = await charlotteMultiSigWallet.updateWitness({ sender: { id: 'e2e' }, tx });
+    const txId = await charlotteMultiSigWallet.submitTx(tx);
+
+    const finalTxFound = await firstValueFrom(
+      aliceMultiSigWallet.transactions.history$.pipe(
+        map((txs) => txs.find((hydratedTx) => hydratedTx.id === txId)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    logger.info(`Found transaction id in chain history: ${finalTxFound.id}`);
+
+    expect(finalTxFound).toBeDefined();
+    expect(finalTxFound.id).toEqual(tx.id);
+    expect(normalizeTxBody(finalTxFound.body)).toEqual(normalizeTxBody(tx.body));
+  });
+});