@cardano-sdk/e2e 0.12.1 → 0.13.0

package/docker-compose.yml

@@ -30,7 +30,7 @@ services:
     ports:
       - ${FILE_SERVER_PORT:-7890}:80
     environment:
-      - NGINX_PORT=80
+      NGINX_PORT: 80
     healthcheck:
       test: ['CMD-SHELL', 'wget -O /dev/null http://localhost || exit 1']
       timeout: 10s
@@ -71,7 +71,7 @@ services:
 
   provider-server:
     environment:
-      - TOKEN_METADATA_SERVER_URL=stub://
+      TOKEN_METADATA_SERVER_URL: stub://
     volumes:
       - ./local-network/config/network:/config
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "engines": {
     "node": ">=16.0"
@@ -45,7 +45,7 @@
     "test:web-extension:watch:run": "yarn test:web-extension:run --watch",
     "test:web-extension:watch": "run-s test:web-extension:build test:web-extension:watch:bg",
     "test:web-extension:watch:bg": "run-p test:web-extension:watch:build test:web-extension:watch:run",
-    "local-network:common": "docker compose -p local-network-e2e -f docker-compose.yml -f ../../compose/common.yml $FILES up",
+    "local-network:common": "USE_BLOCKFROST=false docker compose -p local-network-e2e -f docker-compose.yml -f ../../compose/common.yml $FILES up",
     "local-network:up": "FILES='' yarn local-network:common",
     "local-network:dev": "FILES='-f ../../compose/dev.yml' yarn local-network:common",
     "local-network:profile:up": "FILES='-f ../../compose/pg-agent.yml' yarn local-network:common",
@@ -73,20 +73,6 @@
     "wait-for-network": "ts-node src/scripts/is-local-network-ready.ts"
   },
   "repository": "https://github.com/input-output-hk/cardano-js-sdk",
-  "contributors": [
-    "Rhys Bartels-Waller <rhys.bartelswaller@iohk.io> (https://iohk.io)",
-    "Martynas Kazlauskas <martynas.kazlauskas@iohk.io> (https://iohk.io)",
-    "Daniele Ricci <daniele.ricci@iohk.io> (https://iohk.io)",
-    "Ivaylo Andonov <ivaylo.andonov@iohk.io> (https://iohk.io)",
-    "Mircea Hasegan <mircea.hasegan@iohk.io> (https://iohk.io)",
-    "Angel Castillo Bacigalupi <angel.castillo@iohk.io> (https://iohk.io)",
-    "Seung Eun Song <seungeun.song@iohk.io> (https://iohk.io)",
-    "Dmytro Iakymenko <dmytro.iakymenko@iohk.io> (https://iohk.io)",
-    "Tomislav Horaček <tomislav.horacek@iohk.io> (https://iohk.io)",
-    "Michael Chappell <michael.chappell@iohk.io> (https://iohk.io)",
-    "Leonel Gobbi <leonel.gobbi@globant.com> (https://www.globant.com)",
-    "Juan Cruz Vieiro <juan.vieiro@globant.com> (https://www.globant.com)"
-  ],
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -94,18 +80,18 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^6.0.0",
     "@cardano-ogmios/client": "5.6.0",
-    "@cardano-sdk/cardano-services": "~0.11.4",
-    "@cardano-sdk/cardano-services-client": "~0.9.3",
-    "@cardano-sdk/core": "~0.12.2",
-    "@cardano-sdk/crypto": "~0.1.5",
-    "@cardano-sdk/hardware-ledger": "~0.2.2",
-    "@cardano-sdk/key-management": "~0.7.1",
-    "@cardano-sdk/ogmios": "~0.11.3",
-    "@cardano-sdk/tx-construction": "~0.5.2",
-    "@cardano-sdk/util": "~0.10.0",
-    "@cardano-sdk/util-dev": "~0.11.1",
-    "@cardano-sdk/util-rxjs": "~0.4.10",
-    "@cardano-sdk/wallet": "~0.13.1",
+    "@cardano-sdk/cardano-services": "~0.12.0",
+    "@cardano-sdk/cardano-services-client": "~0.9.4",
+    "@cardano-sdk/core": "~0.13.0",
+    "@cardano-sdk/crypto": "~0.1.6",
+    "@cardano-sdk/hardware-ledger": "~0.2.3",
+    "@cardano-sdk/key-management": "~0.7.2",
+    "@cardano-sdk/ogmios": "~0.12.0",
+    "@cardano-sdk/tx-construction": "~0.5.3",
+    "@cardano-sdk/util": "~0.11.0",
+    "@cardano-sdk/util-dev": "~0.12.0",
+    "@cardano-sdk/util-rxjs": "~0.4.11",
+    "@cardano-sdk/wallet": "~0.14.0",
     "@vespaiach/axios-fetch-adapter": "^0.3.0",
     "axios": "^0.27.2",
     "bunyan": "^1.8.15",
@@ -130,10 +116,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.9.3",
-    "@cardano-sdk/projection": "~0.6.3",
-    "@cardano-sdk/projection-typeorm": "~0.2.3",
-    "@cardano-sdk/web-extension": "~0.11.1",
+    "@cardano-sdk/dapp-connector": "~0.9.4",
+    "@cardano-sdk/projection": "~0.6.4",
+    "@cardano-sdk/projection-typeorm": "~0.3.0",
+    "@cardano-sdk/web-extension": "~0.12.0",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -165,6 +151,7 @@
     "null-loader": "^4.0.1",
     "readable-stream": "^3.6.0",
     "shx": "^0.3.3",
+    "source-map-loader": "^4.0.1",
     "ts-jest": "^28.0.7",
     "typeorm": "^0.3.15",
     "typeorm-extension": "^2.7.0",
@@ -177,5 +164,5 @@
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
-  "gitHead": "b08d0557134f582cafb68ed535840d70cd93f0e7"
+  "gitHead": "c7c3523ee84b5ec53d781b0e05511c2312fd6397"
 }

package/test/blockfrost/StakePoolCompare.test.ts

@@ -100,7 +100,7 @@ describe('StakePoolCompare', () => {
 
   // Fetch all stake pools with all reward history and organize in a StakePoolRecord
   const fetchAll = async (provider: StakePoolProvider) =>
-    Object.fromEntries((await fetchAllPools(provider, { rewardsHistoryLimit: 1_000_000 })).map((_) => [_.id, _]));
+    Object.fromEntries((await fetchAllPools(provider, { apyEpochsBackLimit: 1_000_000 })).map((_) => [_.id, _]));
 
   const startServer = async (args: string[]) => {
     const port = await getRandomPort();
@@ -170,8 +170,8 @@ describe('StakePoolCompare', () => {
       let metricTwo: Cardano.StakePoolMetrics;
 
       beforeAll(() => {
-        metricOne = poolOne.metrics;
-        metricTwo = poolTwo.metrics;
+        metricOne = poolOne.metrics!;
+        metricTwo = poolTwo.metrics!;
       });
 
       // check apy
@@ -212,12 +212,6 @@ describe('StakePoolCompare', () => {
 
     it('rewardAccount', () => expect(poolOne.rewardAccount).toBe(poolTwo.rewardAccount));
 
-    describe('transactions', () => {
-      it('registration', () => expect(poolOne.transactions.registration).toEqual(poolTwo.transactions.registration));
-
-      it('retirement', () => expect(poolOne.transactions.retirement).toEqual(poolTwo.transactions.retirement));
-    });
-
     // a known problem on db-sync implementation makes this test to fail on the given preprod pools
     if (!poolsExcludeStatus.has(id)) it('status', () => expect(poolOne.status).toBe(poolTwo.status));
     else it('status', () => expect(poolOne.status).not.toBe(poolTwo.status));
@@ -230,14 +224,14 @@ describe('StakePoolCompare', () => {
       const result = await fetchAllPools(providerOne, { sort: { field: 'saturation', order: 'asc' } });
 
       for (let i = 1; i < result.length; ++i)
-        expect(result[i - 1].metrics.saturation).toBeLessThanOrEqual(result[i].metrics.saturation);
+        expect(result[i - 1].metrics?.saturation).toBeLessThanOrEqual(result[i].metrics!.saturation);
     });
 
     it('by saturation desc', async () => {
       const result = await fetchAllPools(providerOne, { sort: { field: 'saturation', order: 'desc' } });
 
       for (let i = 1; i < result.length; ++i)
-        expect(result[i - 1].metrics.saturation).toBeGreaterThanOrEqual(result[i].metrics.saturation);
+        expect(result[i - 1].metrics?.saturation).toBeGreaterThanOrEqual(result[i].metrics!.saturation);
     });
   });
 
@@ -261,7 +255,7 @@ describe('StakePoolCompare', () => {
 
         statusCount[pool.status]++;
 
-        if (pool.metrics.livePledge >= pool.pledge) poolsMeetingPledge++;
+        if (pool.metrics!.livePledge >= pool.pledge) poolsMeetingPledge++;
         else {
           poolsNotMeetingPledge++;
 

package/test/local-network/register-pool.test.ts

@@ -144,7 +144,7 @@ describe('local-network/register-pool', () => {
     expect(result.pageResults[0].hexId).toBe(Cardano.PoolIdHex(poolKeyHash));
     expect(result.pageResults[0].id).toBe(poolId);
     expect(result.pageResults[0].status).toBe(Cardano.StakePoolStatus.Activating);
-    expect(result.pageResults[0].metrics.livePledge).toBeLessThan(result.pageResults[0].pledge);
+    expect(result.pageResults[0].metrics?.livePledge).toBeLessThan(result.pageResults[0].pledge);
   });
 
   test('meets pledge', async () => {
@@ -229,6 +229,6 @@ describe('local-network/register-pool', () => {
     expect(result.pageResults[0].hexId).toBe(Cardano.PoolIdHex(poolKeyHash));
     expect(result.pageResults[0].id).toBe(poolId);
     expect(result.pageResults[0].status).toBe(Cardano.StakePoolStatus.Activating);
-    expect(result.pageResults[0].metrics.livePledge).toBeGreaterThan(result.pageResults[0].pledge);
+    expect(result.pageResults[0].metrics?.livePledge).toBeGreaterThan(result.pageResults[0].pledge);
   });
 });

package/test/providers/StakePoolProvider.test.ts

@@ -260,13 +260,13 @@ describe('StakePoolProvider', () => {
       it('with pledgeMet false', async () => {
         const { pageResults } = await query({ pledgeMet: false });
 
-        for (const pool of pageResults) expect(pool.pledge > pool.metrics.livePledge).toBeTruthy();
+        for (const pool of pageResults) expect(pool.pledge > pool.metrics!.livePledge).toBeTruthy();
       });
 
       it('with pledgeMet true', async () => {
         const { pageResults } = await query({ pledgeMet: true });
 
-        for (const pool of pageResults) expect(pool.pledge <= pool.metrics.livePledge).toBeTruthy();
+        for (const pool of pageResults) expect(pool.pledge <= pool.metrics!.livePledge).toBeTruthy();
       });
 
       it('pools number = meeting pools number + not meeting pools number', async () => {

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

@@ -0,0 +1,242 @@
+import { Cardano } from '@cardano-sdk/core';
+import { DelegatedStake, PersonalWallet, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
+import { MINUTE, getWallet } from '../../../src';
+import { Observable, filter, firstValueFrom, map, tap } from 'rxjs';
+import { Percent } from '@cardano-sdk/util';
+import { createLogger } from '@cardano-sdk/util-dev';
+import { firstValueFromTimed, submitAndConfirm, walletReady } from '../../util';
+import { getEnv, walletVariables } from '../../../src/environment';
+
+const env = getEnv(walletVariables);
+const logger = createLogger();
+const TEST_FUNDS = 1_000_000_000n;
+
+/** Distribute the wallet funds evenly across all its addresses */
+const distributeFunds = async (wallet: PersonalWallet) => {
+  await walletReady(wallet, 0n);
+  const addresses = await firstValueFrom(wallet.addresses$);
+  expect(addresses.length).toBeGreaterThan(1);
+
+  // Check that we have enough funds. Otherwise, fund it from wallet account at index 0
+  let { coins: totalCoins } = await firstValueFrom(wallet.balance.utxo.available$);
+
+  const coinDeficit = TEST_FUNDS - totalCoins;
+  if (coinDeficit > 10_000_000n) {
+    logger.debug(
+      `Insufficient funds in wallet account index 1. Missing ${coinDeficit}. Transferring from wallet account index 0`
+    );
+    const fundingWallet = (await getWallet({ env, idx: 0, logger, name: 'WalletAcct0', polling: { interval: 50 } }))
+      .wallet;
+    await walletReady(fundingWallet);
+    const fundingTxBuilder = fundingWallet.createTxBuilder();
+    const { tx } = await fundingTxBuilder
+      .addOutput(fundingTxBuilder.buildOutput().address(addresses[0].address).coin(coinDeficit).toTxOut())
+      .build()
+      .sign();
+    await submitAndConfirm(fundingWallet, tx);
+    await walletReady(wallet);
+    totalCoins = (await firstValueFrom(wallet.balance.utxo.available$)).coins;
+  }
+
+  const coinsPerAddress = totalCoins / BigInt(addresses.length);
+
+  const txBuilder = wallet.createTxBuilder();
+
+  logger.debug(`Sending ${coinsPerAddress} to the ${addresses.length - 1} derived addresses`);
+  // The first one was generated when the wallet was created.
+  for (let i = 1; i < addresses.length; ++i) {
+    const derivedAddress = addresses[i];
+    txBuilder.addOutput(txBuilder.buildOutput().address(derivedAddress.address).coin(coinsPerAddress).toTxOut());
+  }
+
+  const { tx: signedTx } = await txBuilder.build().sign();
+  await submitAndConfirm(wallet, signedTx);
+};
+
+/** await for rewardAccounts$ to be registered, unregistered, as defined in states   */
+const rewardAccountStatuses = async (
+  rewardAccounts$: Observable<Cardano.RewardAccountInfo[]>,
+  statuses: Cardano.StakeKeyStatus[]
+) =>
+  firstValueFromTimed(
+    rewardAccounts$.pipe(
+      tap((accts) => accts.map(({ address, keyStatus }) => logger.debug(address, keyStatus))),
+      map((accts) => accts.map(({ keyStatus }) => keyStatus)),
+      filter((statusArr) => statusArr.every((s) => statuses.includes(s)))
+    ),
+    `Timeout waiting for all reward accounts stake keys to be one of ${statuses.join('|')}`,
+    MINUTE
+  );
+
+/** Create stakeKey deregistration transaction for all reward accounts */
+const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> => {
+  const txBuilder = wallet.createTxBuilder();
+  txBuilder.delegate();
+  const { tx: deregTx } = await txBuilder.build().sign();
+  await submitAndConfirm(wallet, deregTx);
+
+  await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
+    Cardano.StakeKeyStatus.Unregistered,
+    Cardano.StakeKeyStatus.Unregistering
+  ]);
+  logger.debug('Deregistered all stake keys');
+};
+
+const createStakeKeyRegistrationCert = (rewardAccount: Cardano.RewardAccount): Cardano.Certificate => ({
+  __typename: Cardano.CertificateType.StakeKeyRegistration,
+  stakeKeyHash: Cardano.RewardAccount.toHash(rewardAccount)
+});
+
+const createDelegationCert = (rewardAccount: Cardano.RewardAccount, poolId: Cardano.PoolId): Cardano.Certificate => ({
+  __typename: Cardano.CertificateType.StakeDelegation,
+  poolId,
+  stakeKeyHash: Cardano.RewardAccount.toHash(rewardAccount)
+});
+
+const getPoolIds = async (wallet: PersonalWallet, count: number): Promise<Cardano.StakePool[]> => {
+  const activePools = await wallet.stakePoolProvider.queryStakePools({
+    filters: { status: [Cardano.StakePoolStatus.Active] },
+    pagination: { limit: count, startAt: 0 }
+  });
+  expect(activePools.pageResults.length).toBeGreaterThanOrEqual(count);
+  return Array.from({ length: count }).map((_, index) => activePools.pageResults[index]);
+};
+
+const delegateToMultiplePools = async (wallet: PersonalWallet) => {
+  // Delegating to multiple pools should be added in TxBuilder. Doing it manually for now.
+  // Prepare stakeKey registration certificates
+  const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
+  const stakeKeyRegCertificates = rewardAccounts.map(({ address }) => createStakeKeyRegistrationCert(address));
+
+  const poolIds = await getPoolIds(wallet, rewardAccounts.length);
+  const delegationCertificates = rewardAccounts.map(({ address }, index) =>
+    createDelegationCert(address, poolIds[index].id)
+  );
+
+  logger.debug(
+    `Delegating to pools ${poolIds.map(({ id }) => id)} and registering ${stakeKeyRegCertificates.length} stake keys`
+  );
+
+  const txBuilder = wallet.createTxBuilder();
+  // Artificially add the certificates in TxBuilder. An api improvement will make the UX better
+  txBuilder.partialTxBody.certificates = [...stakeKeyRegCertificates, ...delegationCertificates];
+  const { tx } = await txBuilder.build().sign();
+  await submitAndConfirm(wallet, tx);
+  return poolIds;
+};
+
+describe('PersonalWallet/delegationDistribution', () => {
+  let wallet: PersonalWallet;
+
+  beforeAll(async () => {
+    wallet = (await getWallet({ env, idx: 1, logger, name: 'Wallet', polling: { interval: 50 } })).wallet;
+    await distributeFunds(wallet);
+    await deregisterAllStakeKeys(wallet);
+  });
+
+  afterAll(() => {
+    wallet.shutdown();
+  });
+
+  it('reports observable wallet multi delegation as delegationDistribution by pool', async () => {
+    await walletReady(wallet);
+    const walletAddresses = await firstValueFromTimed(wallet.addresses$);
+    const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
+
+    // No stake distribution initially
+    const delegationDistribution = await firstValueFrom(wallet.delegation.distribution$);
+    expect(delegationDistribution).toEqual(new Map());
+
+    const poolIds = await delegateToMultiplePools(wallet);
+
+    // Check that reward addresses were delegated
+    await walletReady(wallet);
+    await rewardAccountStatuses(wallet.delegation.rewardAccounts$, [
+      Cardano.StakeKeyStatus.Registering,
+      Cardano.StakeKeyStatus.Registered
+    ]);
+    logger.debug('Delegations successfully done');
+
+    const totalBalance = await firstValueFrom(wallet.balance.utxo.total$);
+    const perAddrBalance = await Promise.all(
+      rewardAccounts.map((_, index) => {
+        const address = walletAddresses[index].address;
+        return firstValueFrom(
+          createUtxoBalanceByAddressTracker(wallet.utxo, [address]).utxo.total$.pipe(map(({ coins }) => coins))
+        );
+      })
+    );
+
+    // Check delegation.delegationDistribution$ has the delegation information
+    const expectedDelegationDistribution: DelegatedStake[] = rewardAccounts.map(({ address }, index) => ({
+      percentage: Percent(Number(perAddrBalance[index]) / Number(totalBalance.coins)),
+      pool: expect.objectContaining({ id: poolIds[index].id }),
+      rewardAccounts: [address],
+      stake: perAddrBalance[index]
+    }));
+    const actualDelegationDistribution = await firstValueFrom(wallet.delegation.distribution$);
+
+    expect([...actualDelegationDistribution.values()]).toEqual(expectedDelegationDistribution);
+
+    // Send all coins to the last address. Check that stake distribution is 100 for that address and 0 for the rest
+    const { coins: totalCoins } = await firstValueFrom(wallet.balance.utxo.total$);
+    let txBuilder = wallet.createTxBuilder();
+    const { tx: txMoveFunds } = await txBuilder
+      .addOutput(
+        txBuilder
+          .buildOutput()
+          .address(walletAddresses[walletAddresses.length - 1].address)
+          .coin(totalCoins - 2_000_000n) // leave some behind for fees
+          .toTxOut()
+      )
+      .build()
+      .sign();
+    await submitAndConfirm(wallet, txMoveFunds);
+
+    let simplifiedDelegationDistribution: Partial<DelegatedStake>[] = await firstValueFrom(
+      wallet.delegation.distribution$.pipe(
+        map((delegatedStake) =>
+          [...delegatedStake.values()].map(({ pool, percentage }) => ({
+            id: pool.id,
+            name: pool.metadata?.name,
+            percentage
+          }))
+        )
+      )
+    );
+    expect(simplifiedDelegationDistribution).toEqual(
+      rewardAccounts.map((_, index) => ({
+        id: poolIds[index].id,
+        name: poolIds[index].metadata?.name,
+        // Expect approx 100% allocation to the last address
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        percentage: (expect as any).closeTo(index === walletAddresses.length - 1 ? 1 : 0)
+      }))
+    );
+
+    // Delegate all reward accounts to the same pool. delegationDistribution$ should have 1 entry with 100% distribution
+    txBuilder = wallet.createTxBuilder();
+    const { tx: txDelegateTo1Pool } = await txBuilder.delegate(poolIds[0].id).build().sign();
+    await submitAndConfirm(wallet, txDelegateTo1Pool);
+    simplifiedDelegationDistribution = await firstValueFrom(
+      wallet.delegation.distribution$.pipe(
+        map((distribution) =>
+          [...distribution.values()].map((delegatedStake) => ({
+            id: delegatedStake.pool.id,
+            name: delegatedStake.pool.metadata?.name,
+            percentage: delegatedStake.percentage,
+            rewardAccounts: delegatedStake.rewardAccounts
+          }))
+        )
+      )
+    );
+    expect(simplifiedDelegationDistribution).toEqual([
+      {
+        id: poolIds[0].id,
+        name: poolIds[0].metadata?.name,
+        percentage: Percent(1),
+        rewardAccounts: rewardAccounts.map(({ address }) => address)
+      }
+    ]);
+  });
+});

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

@@ -65,17 +65,13 @@ describe('PersonalWallet/multiAddress', () => {
       );
 
       addressesToBeDiscovered.push(address);
-
-      const txOutput = await txBuilder.buildOutput().address(address.address).coin(3_000_000n).build();
-      txBuilder.addOutput(txOutput);
+      txBuilder.addOutput(txBuilder.buildOutput().address(address.address).coin(3_000_000n).toTxOut());
     }
 
     // Remove duplicates
     addressesToBeDiscovered = [...new Set(addressesToBeDiscovered)];
 
-    const unsignedTx = txBuilder.build();
-
-    const { tx: signedTx } = await unsignedTx.sign();
+    const { tx: signedTx } = await txBuilder.build().sign();
 
     await wallet.submitTx(signedTx);
 
@@ -125,17 +121,17 @@ describe('PersonalWallet/multiAddress', () => {
     txBuilder = newWallet.wallet.createTxBuilder();
 
     const fundingWalletAddresses = await firstValueFromTimed(wallet.addresses$);
-    const returnAdaOutput = await txBuilder
-      .buildOutput()
-      .address(fundingWalletAddresses[0].address)
-      .coin(totalBalance.coins - 1_500_000n) // Let's leave some behind for fees.
-      .build();
-
-    txBuilder.addOutput(returnAdaOutput);
 
-    const returnAdaUnsignedTx = await txBuilder.build();
-
-    const { tx: returnAdaSignedTx } = await returnAdaUnsignedTx.sign();
+    const { tx: returnAdaSignedTx } = await txBuilder
+      .addOutput(
+        txBuilder
+          .buildOutput()
+          .address(fundingWalletAddresses[0].address)
+          .coin(totalBalance.coins - 1_500_000n) // Let's leave some behind for fees.
+          .toTxOut()
+      )
+      .build()
+      .sign();
     await newWallet.wallet.submitTx(returnAdaSignedTx);
 
     // Search chain history to see if the transaction is there.

package/test/web-extension/extension/manifest.json

@@ -9,7 +9,7 @@
     "unlimitedStorage"
   ],
   "content_security_policy": {
-    "extension_pages": "default-src 'self' http://localhost:3000; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; connect-src data: http://localhost:8080 https://api.coingecko.com http://167.235.156.245:4000 http://localhost:3000 ws://localhost:3000 wss://localhost:3000 http://localhost:4000 ws://localhost:4000 wss://localhost:4000 http://testnet-dev-backend.dev.lw.iog.io:80 http://localhost:4567 https://testnet-dev-backend.dev.lw.iog.io:443 https://preprod-api.v2.prod.lw.iog.io; style-src * 'unsafe-inline'; img-src * data:; font-src https://fonts.gstatic.com;"
+    "extension_pages": "default-src 'self' http://localhost:3000; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; connect-src data: http://localhost:8080 https://backend.live-preprod.eks.lw.iog.io https://api.coingecko.com http://167.235.156.245:4000 http://localhost:3000 ws://localhost:3000 wss://localhost:3000 http://localhost:4000 ws://localhost:4000 wss://localhost:4000 http://testnet-dev-backend.dev.lw.iog.io:80 http://localhost:4567 https://testnet-dev-backend.dev.lw.iog.io:443 https://preprod-api.v2.prod.lw.iog.io; style-src * 'unsafe-inline'; img-src * data:; font-src https://fonts.gstatic.com;"
   },
   "web_accessible_resources": [
     {

package/test/web-extension/webpack.config.base.js

@@ -9,7 +9,8 @@ require('dotenv').config({ path: path.join(__dirname, '../../', '.env') });
 
 module.exports = {
   baseConfig: {
-    devtool: 'inline-source-map',
+    devtool: 'source-map',
+    ignoreWarnings: [/Failed to parse source map/],
     mode: 'development',
     module: {
       // configuration regarding modules
@@ -18,6 +19,11 @@ module.exports = {
           test: /docker\.js$/,
           use: 'null-loader'
         },
+        {
+          enforce: 'pre',
+          test: /\.js$/,
+          use: ['source-map-loader']
+        },
         {
           exclude: /node_modules/,
           resolve: {