@cardano-sdk/e2e 0.12.0 → 0.13.0

package/test/pg-boss/stake-pool-metrics.test.ts

@@ -0,0 +1,44 @@
+import { Pool } from 'pg';
+import { STAKE_POOL_METRICS_UPDATE } from '@cardano-sdk/projection-typeorm';
+import { getEnv } from '../../src';
+
+const selectRowsCount = async (db: Pool, table: string) => {
+  const query = `SELECT COUNT(*) FROM ${table}`;
+  const { rows } = await db.query(query);
+
+  return rows;
+};
+
+describe('stake-pool-metrics', () => {
+  const key = 'STAKE_POOL_CONNECTION_STRING';
+  const connectionString = getEnv([key])[key];
+  const db = new Pool({ connectionString });
+
+  it('populates current_pool_metrics table', async () => {
+    let jobState: string[] | undefined;
+
+    // Wait until at least one job completed
+    while (!jobState?.filter((_) => _ === 'completed').length) {
+      // If it is not the first iteration, wait for a while
+      if (jobState) await new Promise((resolve) => setTimeout(resolve, 5000));
+
+      try {
+        const query = 'SELECT state FROM pgboss.job WHERE name = $1';
+        const { rows } = await db.query<{ state: string }>(query, [STAKE_POOL_METRICS_UPDATE]);
+
+        jobState = rows.map(({ state }) => state);
+      } catch (error) {
+        const allowedErrors = ['database "projection" does not exist', 'relation "pgboss.job" does not exist'];
+
+        // In case the projection service has not yet created the database or the schema, simulate an empty result to wait
+        if (error instanceof Error && allowedErrors.includes(error.message)) jobState = [];
+        else throw error;
+      }
+    }
+
+    const metricsRows = await selectRowsCount(db, 'current_pool_metrics');
+    const poolsRows = await selectRowsCount(db, 'stake_pool');
+
+    expect(metricsRows).toEqual(poolsRows);
+  });
+});

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/.env.example

@@ -16,6 +16,8 @@ UTXO_PROVIDER=http
 UTXO_PROVIDER_PARAMS='{"baseUrl":"http://localhost:4000/utxo"}'
 STAKE_POOL_PROVIDER=stub
 STAKE_POOL_PROVIDER_PARAMS='{"baseUrl":"http://localhost:4000/stake-pool"}'
+HANDLE_PROVIDER=handleProvider
+HANDLE_PROVIDER_PARAMS='{"serverUrl":"http://localhost:4000","policyId":""}'
 
 # Test Environment
 NETWORK_ID=0

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: {