test: add a unit test to create and sign a transaction that transfer 300 assets

Author: AngelCastilloB

Diff for: packages/util-dev/src/dataGeneration.ts

@@ -0,0 +1,19 @@
+/**
+ * Generates a random byte array in hexadecimal value.
+ *
+ * @param size The size of the hex string in bytes.
+ */
+export const generateRandomHexString = (size: number) =>
+  [...Array.from({ length: size })]
+    .map(() => Math.floor(Math.random() * 16).toString(16))
+    .join('')
+    .toLowerCase();
+
+/**
+ * Generates a random BigInt number between two values.
+ *
+ * @param min The minimum value.
+ * @param max The maximum value.
+ */
+export const generateRandomBigInt = (min: number, max: number): bigint =>
+  BigInt(Math.floor(Math.random() * (max + 1 - min) + min));

Diff for: packages/util-dev/src/index.ts

@@ -8,3 +8,4 @@ export * from './stubLogger';
 export * from './testScheduler';
 export * from './createStubUtxoProvider';
 export * from './createGenericMockServer';
+export * from './dataGeneration';

Diff for: packages/util-dev/test/dataGeneration.test.ts

@@ -0,0 +1,21 @@
+import { generateRandomBigInt, generateRandomHexString } from '../src';
+
+describe('dataGeneration', () => {
+  describe('generateRandomHexString', () => {
+    it('generates a valid hex string', () => {
+      const hex = generateRandomHexString(10);
+      expect(!Number.isNaN(Number(`0x${hex}`))).toBeTruthy();
+    });
+    it('generates hex string of the correct size', () => {
+      const hex = generateRandomHexString(10);
+      expect(hex.length).toEqual(10);
+    });
+  });
+  describe('generateRandomBigInt', () => {
+    it('generates a bigint between the given range', () => {
+      const bigInt = generateRandomBigInt(10_000, 20_000);
+      expect(bigInt).toBeLessThanOrEqual(20_000);
+      expect(bigInt).toBeGreaterThanOrEqual(10_000);
+    });
+  });
+});

Diff for: packages/wallet/test/SingleAddressWallet/load.test.ts

@@ -2,7 +2,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as mocks from '../mocks';
 import { AddressType, GroupedAddress } from '@cardano-sdk/key-management';
-import { AssetId, createStubStakePoolProvider, somePartialStakePools } from '@cardano-sdk/util-dev';
+import {
+  AssetId,
+  createStubStakePoolProvider,
+  generateRandomBigInt,
+  generateRandomHexString,
+  somePartialStakePools
+} from '@cardano-sdk/util-dev';
 import {
   Cardano,
   ChainHistoryProvider,
@@ -165,6 +171,62 @@ const assertWalletProperties2 = async (wallet: ObservableWallet) => {
   expect(rewardAccounts[0].rewardBalance).toBe(mocks.rewardAccountBalance2);
 };
 
+/**
+ * Generates a set of UTXOs matching the given parameters.
+ *
+ * @param utxoCount The number of UTXOs to be generated.
+ * @param assetsPerUtxo The number of Assets per UTXO.
+ */
+const generateUtxos = (utxoCount: number, assetsPerUtxo: number): Cardano.Utxo[] => {
+  const utxos: Cardano.Utxo[] = [];
+
+  for (let utxoIndex = 0; utxoIndex < utxoCount; ++utxoIndex) {
+    const utxo: Cardano.Utxo = [
+      {
+        address,
+        index: 0,
+        txId: Cardano.TransactionId(generateRandomHexString(64))
+      },
+      {
+        address,
+        value: {
+          assets: new Map(),
+          coins: generateRandomBigInt(1_000_000, 9_999_999_000_000) // from 1 tADA to 9.999.999 tADA
+        }
+      }
+    ];
+    for (let assetIndex = 0; assetIndex < assetsPerUtxo; ++assetIndex) {
+      utxo[1].value!.assets!.set(Cardano.AssetId(generateRandomHexString(72)), generateRandomBigInt(1, 1000));
+    }
+
+    utxos.push(utxo);
+  }
+
+  return utxos;
+};
+
+/**
+ * Gets the asset list and the total amount of lovelace on a utxo set.
+ *
+ * @param utxos The utxos.
+ * @returns The total lovelace and the aggregated asset set.
+ */
+const getAssetsFromUtxos = (utxos: Cardano.Utxo[]) => {
+  const values = utxos.map((utxo) => utxo[1].value);
+  let totalLovelace = 0n;
+  const totalTokens = new Map();
+
+  for (const value of values) {
+    totalLovelace += value.coins;
+
+    for (const [key, val] of value.assets!.entries()) {
+      totalTokens.set(key, val);
+    }
+  }
+
+  return { totalLovelace, totalTokens };
+};
+
 describe('SingleAddressWallet load', () => {
   it('loads all properties from provider, stores them and restores on subsequent load, fetches new data', async () => {
     const stores = createInMemoryWalletStores();
@@ -288,3 +350,43 @@ describe('SingleAddressWallet load', () => {
     wallet.shutdown();
   });
 });
+
+describe('SingleAddressWallet creates big UTXO', () => {
+  it('creates an UTXO with 300 hundred mixed assets coming from several inputs', async () => {
+    const stores = createInMemoryWalletStores();
+    const utxoSet = generateUtxos(30, 10);
+    const totalAssets = getAssetsFromUtxos(utxoSet);
+
+    const wallet = await createWallet(stores, {
+      chainHistoryProvider: mocks.mockChainHistoryProvider(),
+      networkInfoProvider: mocks.mockNetworkInfoProvider(),
+      rewardsProvider: mocks.mockRewardsProvider(),
+      utxoProvider: mocks.mockUtxoProvider(utxoSet)
+    });
+
+    const txProps = {
+      outputs: new Set([
+        {
+          address,
+          value: {
+            assets: totalAssets.totalTokens,
+            coins: totalAssets.totalLovelace - 10_000_000n // Leave some tADA available for fees
+          }
+        }
+      ])
+    };
+
+    const unsignedTx = await wallet.initializeTx(txProps);
+
+    const finalizeProps = {
+      tx: unsignedTx
+    };
+
+    const signedTx = await wallet.finalizeTx(finalizeProps);
+
+    const nonChangeOutput = signedTx.body.outputs.find((out) => out.value!.assets!.size > 0);
+    expect(nonChangeOutput!.value.assets).toBe(totalAssets.totalTokens);
+
+    wallet.shutdown();
+  });
+});

Diff for: packages/wallet/test/mocks/mockUtxoProvider.ts

@@ -66,11 +66,13 @@ export const utxo2 = utxo.slice(1);
 /**
  * Provider stub for testing
  *
+ * @param utxoSet The set of UTXOs to be included in the wallet state.
+ *
  * returns UtxoProvider-compatible object
  */
-export const mockUtxoProvider = (): UtxoProvider => ({
+export const mockUtxoProvider = (utxoSet?: Cardano.Utxo[]): UtxoProvider => ({
   healthCheck: jest.fn().mockResolvedValue({ ok: true }),
-  utxoByAddresses: jest.fn().mockResolvedValue(utxo)
+  utxoByAddresses: jest.fn().mockResolvedValue(utxoSet ? utxoSet : utxo)
 });
 
 export const mockUtxoProvider2 = (delayMs: number): UtxoProvider => {