@cardano-sdk/e2e 0.14.1 → 0.14.2

package/src/tools/multi-delegation-data-gen/utils/utils.ts

@@ -0,0 +1,416 @@
+/* eslint-disable no-console, max-statements, max-params, @typescript-eslint/no-floating-promises */
+import { ValueTransferConfig, configLoader } from './config';
+
+import { AddressType, AsyncKeyAgent, GroupedAddress, util } from '@cardano-sdk/key-management';
+import { Cardano } from '@cardano-sdk/core';
+import { Files, Paths } from './files';
+import {
+  KeyAgentFactoryProps,
+  MINUTE,
+  firstValueFromTimed,
+  getEnv,
+  getWallet,
+  submitAndConfirm,
+  walletReady,
+  walletVariables
+} from '../../../';
+import { Observable, filter, firstValueFrom, map } from 'rxjs';
+import { PersonalWallet } from '@cardano-sdk/wallet';
+import { TaskResult, TerminalProgressMonitor } from './terminal-progress-monitor';
+import { logger } from '@cardano-sdk/util-dev';
+import chalk from 'chalk';
+
+/**
+ * Gets grouped addresses with increasing stake key index.
+ *
+ * @param keyAgent The key agent to be used to generate the addresses.
+ * @param addressCount Number of addresses to be generated.
+ */
+export const getStakeAddresses = async (
+  keyAgent: AsyncKeyAgent,
+  addressCount: number
+): Promise<Array<GroupedAddress>> => {
+  const addresses = new Array<GroupedAddress>();
+
+  for (let i = 0; i < addressCount; ++i) {
+    const address = await keyAgent.deriveAddress(
+      {
+        index: 0,
+        type: AddressType.External
+      },
+      i
+    );
+
+    addresses.push(address);
+  }
+
+  return addresses;
+};
+
+/**
+ * Gets a list of the available pool.
+ *
+ * @param wallet The wallet to get the pools from.
+ * @param count The requested number of pools.
+ */
+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 }
+  });
+
+  return Array.from({ length: count }).map((_, index) => activePools.pageResults[index]);
+};
+
+/**
+ * Awaits for rewardAccounts$ to be registered, unregistered, as defined in states.
+ *
+ * @param rewardAccounts$ The reward accounts observable.
+ * @param statuses the statuses we are waiting for.
+ * @param timeout the amount of time we will wait for the status to change.
+ */
+export const rewardAccountStatuses = async (
+  rewardAccounts$: Observable<Cardano.RewardAccountInfo[]>,
+  statuses: Cardano.StakeKeyStatus[],
+  timeout = MINUTE
+) =>
+  firstValueFromTimed(
+    rewardAccounts$.pipe(
+      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('|')}`,
+    timeout
+  );
+
+/**
+ * Registers and delegates reward accounts to different pools.
+ */
+export const delegateToMultiplePools = async (
+  fundingWallet: PersonalWallet,
+  rewardAccounts: GroupedAddress[],
+  monitor: TerminalProgressMonitor
+) => {
+  const stakeKeyRegCertificates = rewardAccounts.map(({ rewardAccount }) =>
+    Cardano.createStakeKeyRegistrationCert(rewardAccount)
+  );
+  const poolIds = await getPoolIds(fundingWallet, rewardAccounts.length);
+  const delegationCertificates = rewardAccounts.map((account) =>
+    Cardano.createDelegationCert(account.rewardAccount, poolIds[account.stakeKeyDerivationPath!.index].id)
+  );
+
+  monitor.logInfo(
+    `Registering accounts: [${chalk.green(rewardAccounts.map(({ rewardAccount }) => rewardAccount).join(', '))}]`
+  );
+
+  monitor.startTask(
+    `Delegating to pools [${chalk.green(poolIds.map(({ id }) => id).join(', '))}] and registering ${chalk.green(
+      stakeKeyRegCertificates.length
+    )} stake keys`
+  );
+
+  const txBuilder = fundingWallet.createTxBuilder();
+
+  txBuilder.partialTxBody.certificates = [...stakeKeyRegCertificates, ...delegationCertificates];
+  const { tx } = await txBuilder.build().sign();
+  await submitAndConfirm(fundingWallet, tx);
+
+  monitor.endTask('Stake keys delegated', TaskResult.Success);
+
+  return poolIds;
+};
+
+const env = getEnv(walletVariables);
+
+/**
+ * Formats a given number with the given number of decimals.
+ *
+ * @param num The number to be formatted.
+ * @param decimals The number of decimals.
+ */
+const format = (num: number, decimals: number) =>
+  num.toLocaleString('en-US', {
+    maximumFractionDigits: decimals,
+    minimumFractionDigits: decimals
+  });
+
+/**
+ * Loads the application configuration.
+ *
+ * @param monitor The progress monitor
+ */
+export const loadConfiguration = async (monitor: TerminalProgressMonitor) => {
+  const configFilePath = process.argv[2];
+
+  monitor.startTask(`Loading config file from ${chalk.green(configFilePath)}.`);
+
+  configLoader.loadFile(configFilePath);
+  configLoader.validate({ allowed: 'strict' });
+
+  monitor.endTask(`Configuration loaded from ${chalk.green(configFilePath)}`, TaskResult.Success);
+
+  return configLoader.getProperties();
+};
+
+/**
+ * Waits until the funding wallet is ready.
+ *
+ * @param monitor The progress monitor
+ */
+export const waitForFundingWallet = async (monitor: TerminalProgressMonitor): Promise<PersonalWallet> => {
+  monitor.startTask('Waiting for funding wallet to be ready.');
+
+  const fundingWallet = (await getWallet({ env, idx: 0, logger, name: 'Funding wallet', polling: { interval: 500 } }))
+    .wallet;
+
+  await walletReady(fundingWallet);
+
+  monitor.endTask('Funding wallet ready', TaskResult.Success);
+
+  return fundingWallet;
+};
+
+/**
+ * Creates a new delegation wallet.
+ *
+ * @param monitor The progress monitor.
+ */
+export const createDelegationWallet = async (monitor: TerminalProgressMonitor) => {
+  monitor.startTask('Creating a random set of mnemonics for a brand-new wallet.');
+
+  const mnemonics = util.generateMnemonicWords();
+
+  monitor.endTask(`Mnemonics generated: [${chalk.green!(mnemonics.join(', '))}]`, TaskResult.Success);
+
+  const customKeyParams: KeyAgentFactoryProps = {
+    accountIndex: 0,
+    chainId: env.KEY_MANAGEMENT_PARAMS.chainId,
+    mnemonic: mnemonics.join(' '),
+    passphrase: 'some_passphrase'
+  };
+
+  return (
+    await getWallet({
+      customKeyParams,
+      env,
+      idx: 0,
+      logger,
+      name: 'Delegation Wallet',
+      polling: { interval: 500 }
+    })
+  ).wallet;
+};
+
+/**
+ * Transfers the starting funds from the funding wallet to the delegation wallet.
+ *
+ * @param fundingWallet The funding wallet contains the original funds, and serves as a faucet.
+ * @param delegationWallet The delegation wallet is our test wallet.
+ * @param startingFunds The initial funds to be transferred.
+ * @param monitor The progress monitor.
+ */
+export const transferStartingFunds = async (
+  fundingWallet: PersonalWallet,
+  delegationWallet: PersonalWallet,
+  startingFunds: number,
+  monitor: TerminalProgressMonitor
+) => {
+  monitor.startTask(`Transferring ${startingFunds} to delegation wallet.`);
+
+  const delegationWalletAddress = await firstValueFrom(delegationWallet.addresses$);
+
+  const txBuilder = fundingWallet.createTxBuilder();
+  txBuilder.addOutput(
+    txBuilder.buildOutput().address(delegationWalletAddress[0].address).coin(BigInt(startingFunds)).toTxOut()
+  );
+
+  const { tx: signedTx } = await txBuilder.build().sign();
+
+  await submitAndConfirm(fundingWallet, signedTx);
+
+  monitor.endTask('Funds transferred', TaskResult.Success);
+};
+
+/**
+ * Generates a list of stake addresses.
+ *
+ * @param delegationWallet The delegation wallets.
+ * @param stakeKeyCount The number of stake keys to use in the generation of the addresses.
+ * @param monitor The progress monitor.
+ */
+export const generateStakeAddresses = async (
+  delegationWallet: PersonalWallet,
+  stakeKeyCount: number,
+  monitor: TerminalProgressMonitor
+) => {
+  monitor.startTask('Generating stake addresses.');
+
+  const stakeAddresses = await getStakeAddresses(delegationWallet.keyAgent, stakeKeyCount);
+
+  monitor.endTask(
+    `Stake addresses generated: [${chalk.green!(stakeAddresses.map(({ rewardAccount }) => rewardAccount).join(', '))}]`,
+    TaskResult.Success
+  );
+
+  return stakeAddresses;
+};
+
+/**
+ * Distribute the stake among different addresses.
+ *
+ * @param delegationWallet The delegation wallets.
+ * @param startingFunds The total starting funds.
+ * @param stakeDistribution The stake distribution to be followed.
+ * @param stakeAddresses The list of stake addresses.
+ * @param monitor The progress monitor.
+ */
+export const distributeStake = async (
+  delegationWallet: PersonalWallet,
+  startingFunds: number,
+  stakeDistribution: Array<number>,
+  stakeAddresses: Array<GroupedAddress>,
+  monitor: TerminalProgressMonitor
+) => {
+  // TODO: Replace with delegatePortfolio once LW-6702 is merged.
+  const totalWeight = stakeDistribution.reduce((sum, current) => sum + current, 0);
+  const stakeDistributionSsPercent = stakeDistribution.map((value) => value / totalWeight);
+  monitor.startTask(`Distribute ${startingFunds} among stake addresses [${stakeDistribution.join(', ')}].`);
+
+  const txBuilder = delegationWallet.createTxBuilder();
+
+  let i = 0;
+  const startingFundsMinusFee = startingFunds - 5_000_000;
+  for (const { address } of stakeAddresses) {
+    const coinsToBeDeposited = stakeDistributionSsPercent[i] * startingFundsMinusFee;
+    txBuilder.addOutput(txBuilder.buildOutput().address(address).coin(BigInt(coinsToBeDeposited)).toTxOut());
+    ++i;
+  }
+
+  const { tx: signedTx } = await txBuilder.build().sign();
+
+  await submitAndConfirm(delegationWallet, signedTx);
+
+  monitor.endTask('Funds distributed', TaskResult.Success);
+};
+
+/**
+ * Logs in the terminal and persist the current state of the wallet.
+ *
+ * @param delegationWallet The delegation wallet.
+ * @param iteration The current test iteration.
+ * @param outputPath The output path were to persist the state.
+ * @param monitor The progress monitor.
+ */
+export const logState = async (
+  delegationWallet: PersonalWallet,
+  iteration: number,
+  outputPath: string,
+  monitor: TerminalProgressMonitor
+) => {
+  const paddedIter = `00000${iteration}`.slice(-4);
+  const delegationDistribution = await firstValueFrom(delegationWallet.delegation.distribution$);
+  const { coins: totalCoins } = await firstValueFrom(delegationWallet.balance.utxo.total$);
+  const utxos = await firstValueFrom(delegationWallet.utxo.total$);
+
+  monitor.logInfo(
+    `${paddedIter} - Total coins: ${totalCoins} - Distribution: [${[...delegationDistribution.values()]
+      .map(
+        (delegatedStake) =>
+          // eslint-disable-next-line sonarjs/no-nested-template-literals
+          `${delegatedStake.stake.toString()}(${chalk.green(`${format(delegatedStake.percentage * 100, 2)}%`)})`
+      )
+      .join(', ')}]`
+  );
+
+  const distributionCSV = Files.combine([outputPath, Paths.StakeDistribution]);
+  const utxoDirectory = Files.combine([outputPath, Paths.WalletUtxos]);
+  const utxosFile = Files.combine([utxoDirectory, `${paddedIter}.json`]);
+
+  Files.createFolder(outputPath);
+  Files.createFolder(utxoDirectory);
+
+  const csvEntries = [totalCoins, [...delegationDistribution.values()].map((delegatedStake) => delegatedStake.stake)];
+
+  Files.writeFile(distributionCSV, `${paddedIter},${csvEntries.join(',')}\n`, true);
+  Files.writeFile(
+    utxosFile,
+    JSON.stringify(utxos, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
+  );
+};
+
+/**
+ * Gets a random number between two intervals.
+ *
+ * @param min The lower bound value of te interval (inclusive).
+ * @param max The upper bound value of te interval (inclusive).
+ */
+export const randomFromInterval = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1) + min);
+
+/**
+ * Creates a folder name using a timestamp.
+ */
+export const getOutputPathName = () =>
+  new Date().toISOString().replace(/(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}).*/, '$1_$2_$3_$4_$5_$6');
+
+/**
+ * Transfer value from one wallet to another following the given value transfer configuration.
+ *
+ * @param wallet The source wallet.
+ * @param targetAddress The target wallet.
+ * @param config The value transfer configuration.
+ * @param currentIteration the current iteration.
+ */
+const transferValue = async (
+  wallet: PersonalWallet,
+  targetAddress: Cardano.PaymentAddress,
+  config: ValueTransferConfig,
+  currentIteration: number
+) => {
+  const outputCount = randomFromInterval(config.count.min, config.count.max);
+  if (outputCount === 0 || config.period === 0 || currentIteration % config.period !== 0) return;
+
+  const txBuilder = wallet.createTxBuilder();
+
+  for (let i = 0; i < outputCount; ++i) {
+    const amountToBeGenerated = randomFromInterval(config.amount.min, config.amount.max);
+    txBuilder.addOutput(txBuilder.buildOutput().address(targetAddress).coin(BigInt(amountToBeGenerated)).toTxOut());
+  }
+
+  const { tx: signedTx } = await txBuilder.build().sign();
+
+  await submitAndConfirm(wallet, signedTx);
+};
+
+/**
+ * Generate and submit transaction following the given input and output configuration.
+ *
+ * This function will create on transaction transferring funds from the funding wallet to the
+ * delegation wallet (inputs), and one transaction transferring funds from the delegation wallet
+ * to the funding wallet (outputs).
+ *
+ * @param fundingWallet The funding wallet contains the original funds, and serves as a faucet.
+ * @param delegationWallet The delegation wallet is our test wallet.
+ * @param inputsConfig The configuration parameters for the input generation.
+ * @param outputsConfig The configuration parameters for the output generation.
+ * @param iteration Tue current iteration we are in.
+ * @param monitor The progress monitor.
+ */
+export const sendTransactions = async (
+  fundingWallet: PersonalWallet,
+  delegationWallet: PersonalWallet,
+  inputsConfig: ValueTransferConfig,
+  outputsConfig: ValueTransferConfig,
+  iteration: number,
+  monitor: TerminalProgressMonitor
+) => {
+  const inputAddress = (await firstValueFrom(delegationWallet.addresses$))[0].address;
+  const outputAddress = (await firstValueFrom(fundingWallet.addresses$))[0].address;
+  const paddedIter = `00000${iteration}`.slice(-4);
+
+  monitor.startTask(`${paddedIter} - Generating incoming and outgoing transactions`);
+
+  await transferValue(fundingWallet, inputAddress, inputsConfig, iteration);
+  await transferValue(delegationWallet, outputAddress, outputsConfig, iteration);
+
+  monitor.endTask('', TaskResult.None);
+};

package/src/util/index.ts

@@ -1,2 +1,3 @@
 export * from './StubKeyAgent';
 export * from './localNetworkChainId';
+export * from './util';

package/{test → src/util}/util.ts

@@ -1,8 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as Crypto from '@cardano-sdk/crypto';
 import * as envalid from 'envalid';
-import { AddressType, GroupedAddress, InMemoryKeyAgent, TransactionSigner } from '@cardano-sdk/key-management';
-import { AddressesModel } from './artillery/wallet-restoration/types';
 import { Cardano, createSlotEpochCalc } from '@cardano-sdk/core';
 import {
   EMPTY,
@@ -20,17 +18,12 @@ import {
   throwError,
   timeout
 } from 'rxjs';
-import {
-  FAST_OPERATION_TIMEOUT_DEFAULT,
-  SYNC_TIMEOUT_DEFAULT,
-  TestWallet,
-  faucetProviderFactory,
-  getEnv,
-  networkInfoProviderFactory,
-  walletVariables
-} from '../src';
+import { FAST_OPERATION_TIMEOUT_DEFAULT, SYNC_TIMEOUT_DEFAULT } from '../defaults';
 import { FinalizeTxProps, ObservableWallet, PersonalWallet } from '@cardano-sdk/wallet';
+import { InMemoryKeyAgent, TransactionSigner } from '@cardano-sdk/key-management';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
+import { TestWallet, faucetProviderFactory, networkInfoProviderFactory } from '../factories';
+import { getEnv, walletVariables } from '../environment';
 import { logger } from '@cardano-sdk/util-dev';
 import sortBy from 'lodash/sortBy';
 
@@ -317,12 +310,3 @@ export const burnTokens = async ({
   await submitAndConfirm(wallet, signedTx);
   await txConfirmed(wallet, signedTx);
 };
-
-export const mapToGroupedAddress = (addrModel: AddressesModel): GroupedAddress => ({
-  accountIndex: 0,
-  address: Cardano.PaymentAddress(addrModel.address),
-  index: 0,
-  networkId: addrModel.address.startsWith('addr_test') ? Cardano.NetworkId.Testnet : Cardano.NetworkId.Mainnet,
-  rewardAccount: Cardano.RewardAccount(addrModel.stake_address),
-  type: AddressType.External
-});

package/test/artillery/wallet-restoration/WalletRestoration.ts

@@ -1,12 +1,20 @@
+import { AddressType, GroupedAddress, util } from '@cardano-sdk/key-management';
 import { AddressesModel, WalletVars } from './types';
 import { Cardano } from '@cardano-sdk/core';
 import { FunctionHook } from '../artillery';
 import { Pool } from 'pg';
-import { StubKeyAgent, getEnv, getWallet, walletVariables } from '../../../src';
+import { StubKeyAgent, getEnv, getWallet, waitForWalletStateSettle, walletVariables } from '../../../src';
 import { findAddressesWithRegisteredStakeKey } from './queries';
 import { logger } from '@cardano-sdk/util-dev';
-import { mapToGroupedAddress, waitForWalletStateSettle } from '../../util';
-import { util } from '@cardano-sdk/key-management';
+
+export const mapToGroupedAddress = (addrModel: AddressesModel): GroupedAddress => ({
+  accountIndex: 0,
+  address: Cardano.PaymentAddress(addrModel.address),
+  index: 0,
+  networkId: addrModel.address.startsWith('addr_test') ? Cardano.NetworkId.Testnet : Cardano.NetworkId.Mainnet,
+  rewardAccount: Cardano.RewardAccount(addrModel.stake_address),
+  type: AddressType.External
+});
 
 const env = getEnv([
   ...walletVariables,

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

@@ -23,9 +23,9 @@ import {
   stakePoolProviderFactory,
   txSubmitProviderFactory,
   utxoProviderFactory,
+  waitForWalletStateSettle,
   walletVariables
 } from '../../../src';
-import { waitForWalletStateSettle } from '../../util';
 
 // Example call that creates 5000 wallets in 10 minutes:
 // VIRTUAL_USERS_GENERATE_DURATION=600 VIRTUAL_USERS_COUNT=5000 yarn load-test-custom:wallet-init

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

@@ -3,13 +3,13 @@
 import * as dotenv from 'dotenv';
 import path from 'path';
 dotenv.config({ path: path.join(__dirname, '../../../.env') });
-import { Cardano } from '@cardano-sdk/core/dist/esm';
+import { Cardano } from '@cardano-sdk/core';
 import { GroupedAddress, util } from '@cardano-sdk/key-management';
 import { Logger } from 'ts-log';
-import { MINUTE, StubKeyAgent, getEnv, getWallet, walletVariables } from '../../../src';
+import { MINUTE, StubKeyAgent, getEnv, getWallet, waitForWalletStateSettle, walletVariables } from '../../../src';
 import { PersonalWallet } from '@cardano-sdk/wallet';
 import { logger } from '@cardano-sdk/util-dev';
-import { mapToGroupedAddress, waitForWalletStateSettle } from '../../util';
+import { mapToGroupedAddress } from '../../artillery/wallet-restoration/WalletRestoration';
 
 /**
  * Env var MAX_USERS sets the maximum number of concurrent users to measure

package/test/load-testing/tx-submit-load.test.ts

@@ -7,9 +7,8 @@ import { RabbitMQContainer } from '../../../cardano-services/test/TxSubmit/rabbi
 import { ServiceNames } from '@cardano-sdk/cardano-services';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { filter, firstValueFrom } from 'rxjs';
-import { getEnv, walletVariables } from '../../src';
+import { getEnv, submitAndConfirm, walletVariables } from '../../src';
 import { getWallet } from '../../src/factories';
-import { submitAndConfirm } from '../util';
 import JSONBig from 'json-bigint';
 import path from 'path';
 

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

@@ -1,8 +1,16 @@
 /* eslint-disable max-statements */
 import { Cardano } from '@cardano-sdk/core';
-import { KeyAgentFactoryProps, TestWallet, getEnv, getWallet, walletVariables } from '../../src';
+import {
+  KeyAgentFactoryProps,
+  TestWallet,
+  getEnv,
+  getWallet,
+  submitCertificate,
+  waitForWalletStateSettle,
+  walletReady,
+  walletVariables
+} from '../../src';
 import { logger } from '@cardano-sdk/util-dev';
-import { submitCertificate, waitForWalletStateSettle, walletReady } from '../util';
 
 import { AddressType, KeyRole } from '@cardano-sdk/key-management';
 import { firstValueFrom } from 'rxjs';

package/test/long-running/cache-invalidation.test.ts

@@ -1,14 +1,18 @@
 /* eslint-disable max-statements */
 import { AddressType, KeyRole } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
-import { KeyAgentFactoryProps, TestWallet, getEnv, getWallet, walletVariables } from '../../src';
 import {
+  KeyAgentFactoryProps,
+  TestWallet,
+  getEnv,
   getTxConfirmationEpoch,
+  getWallet,
   submitCertificate,
   waitForEpoch,
   waitForWalletStateSettle,
-  walletReady
-} from '../util';
+  walletReady,
+  walletVariables
+} from '../../src';
 import { logger } from '@cardano-sdk/util-dev';
 
 const env = getEnv(walletVariables);

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

@@ -1,15 +1,18 @@
 import { Cardano } from '@cardano-sdk/core';
 import { PersonalWallet } from '@cardano-sdk/wallet';
-import { TestWallet, getEnv, getWallet, walletVariables } from '../../src';
-import { firstValueFrom } from 'rxjs';
 import {
+  TestWallet,
+  getEnv,
   getTxConfirmationEpoch,
+  getWallet,
   requestCoins,
   runningAgainstLocalNetwork,
   submitAndConfirm,
   transferCoins,
-  waitForEpoch
-} from '../util';
+  waitForEpoch,
+  walletVariables
+} from '../../src';
+import { firstValueFrom } from 'rxjs';
 import { logger } from '@cardano-sdk/util-dev';
 import { waitForWalletStateSettle } from '../../../wallet/test/util';
 

package/test/util.test.ts

@@ -1,7 +1,7 @@
 import { BehaviorSubject, NEVER, of } from 'rxjs';
 import { Cardano } from '@cardano-sdk/core';
 import { ObservableWallet } from '@cardano-sdk/wallet';
-import { insufficientFundsMessage, walletReady } from './util';
+import { insufficientFundsMessage, walletReady } from '../src';
 
 describe('util for e2e tests', () => {
   describe('walletReady', () => {

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

@@ -4,9 +4,8 @@ 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';
-import { getWallet } from '../../../src';
+import { getWallet, normalizeTxBody, walletReady } from '../../../src';
 import { isNotNil } from '@cardano-sdk/util';
-import { normalizeTxBody, walletReady } from '../../util';
 
 const env = getEnv(walletVariables);
 const logger = createLogger();

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

@@ -2,9 +2,17 @@
 import { BigIntMath } from '@cardano-sdk/util';
 import { Cardano } from '@cardano-sdk/core';
 import { ObservableWallet } from '@cardano-sdk/wallet';
-import { TX_TIMEOUT_DEFAULT, TestWallet, getEnv, getWallet, walletVariables } from '../../../src';
+import {
+  TX_TIMEOUT_DEFAULT,
+  TestWallet,
+  firstValueFromTimed,
+  getEnv,
+  getWallet,
+  waitForWalletStateSettle,
+  walletReady,
+  walletVariables
+} from '../../../src';
 import { combineLatest, filter, firstValueFrom } from 'rxjs';
-import { firstValueFromTimed, waitForWalletStateSettle, walletReady } from '../../util';
 import { logger } from '@cardano-sdk/util-dev';
 
 const env = getEnv(walletVariables);

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

@@ -1,11 +1,10 @@
 import { AddressType } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import { DelegatedStake, PersonalWallet, createUtxoBalanceByAddressTracker } from '@cardano-sdk/wallet';
-import { MINUTE, getWallet } from '../../../src';
+import { MINUTE, firstValueFromTimed, getWallet, submitAndConfirm, walletReady } 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';
 import delay from 'delay';
 
@@ -110,17 +109,6 @@ const deregisterAllStakeKeys = async (wallet: PersonalWallet): Promise<void> =>
   }
 };
 
-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] },
@@ -134,11 +122,11 @@ 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 stakeKeyRegCertificates = rewardAccounts.map(({ address }) => Cardano.createStakeKeyRegistrationCert(address));
 
   const poolIds = await getPoolIds(wallet, rewardAccounts.length);
   const delegationCertificates = rewardAccounts.map(({ address }, index) =>
-    createDelegationCert(address, poolIds[index].id)
+    Cardano.createDelegationCert(address, poolIds[index].id)
   );
 
   logger.debug(