@indigo-labs/indigo-sdk 0.3.15 → 0.3.17

package/tests/rob/rob.test.ts

@@ -1126,8 +1126,8 @@ describe('ROB', () => {
       );
 
       const amtToSpendBefore = robCollateralAmtToSpend(
-        robBefore.utxo,
-        robBefore.datum,
+        robBefore.utxo.assets,
+        robBefore.datum.orderType,
       );
 
       await runAndAwaitTx(
@@ -1149,8 +1149,8 @@ describe('ROB', () => {
       );
 
       const amtToSpendAfter = robCollateralAmtToSpend(
-        adjustedUtxo1.utxo,
-        adjustedUtxo1.datum,
+        adjustedUtxo1.utxo.assets,
+        adjustedUtxo1.datum.orderType,
       );
 
       assert(amtToSpendBefore - amtToSpendAfter === 1_000_000n);
@@ -1170,8 +1170,8 @@ describe('ROB', () => {
       );
 
       const amtToSpendBefore = robCollateralAmtToSpend(
-        robBefore.utxo,
-        robBefore.datum,
+        robBefore.utxo.assets,
+        robBefore.datum.orderType,
       );
 
       await runAndAwaitTx(
@@ -1193,8 +1193,8 @@ describe('ROB', () => {
       );
 
       const amtToSpendAfter = robCollateralAmtToSpend(
-        adjustedUtxo2.utxo,
-        adjustedUtxo2.datum,
+        adjustedUtxo2.utxo.assets,
+        adjustedUtxo2.datum.orderType,
       );
 
       strictEqual(amtToSpendAfter - amtToSpendBefore, 5_000_000n);
@@ -1271,20 +1271,26 @@ describe('ROB', () => {
     };
 
     assert(
-      robAmtToSpend(
-        adjustedUtxo1.utxo,
-        adjustedUtxo1.datum,
-        sysParams.cdpParams.cdpAssetSymbol,
-      ) ===
+      robAmtToSpend(adjustedUtxo1.utxo.assets, adjustedUtxo1.datum.orderType, {
+        currencySymbol: fromHex(
+          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+        ),
+        tokenName: adjustedUtxo1.datum.iasset,
+      }) ===
         20_000_000n - 1_000_000n,
     );
 
     expect(
       assetClassValueOf(adjustedUtxo1.utxo.assets, iassetAc) ===
         robAmtToSpend(
-          adjustedUtxo1.utxo,
-          adjustedUtxo1.datum,
-          sysParams.cdpParams.cdpAssetSymbol,
+          adjustedUtxo1.utxo.assets,
+          adjustedUtxo1.datum.orderType,
+          {
+            currencySymbol: fromHex(
+              sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+            ),
+            tokenName: adjustedUtxo1.datum.iasset,
+          },
         ),
       'IAssets to spend has to equal iassets in UTXO',
     ).toBeTruthy();
@@ -1310,20 +1316,26 @@ describe('ROB', () => {
     const expectedResultAdaAmt = 20_000_000n - 1_000_000n + 5_000_000n;
 
     strictEqual(
-      robAmtToSpend(
-        adjustedUtxo2.utxo,
-        adjustedUtxo2.datum,
-        sysParams.cdpParams.cdpAssetSymbol,
-      ),
+      robAmtToSpend(adjustedUtxo2.utxo.assets, adjustedUtxo2.datum.orderType, {
+        currencySymbol: fromHex(
+          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+        ),
+        tokenName: adjustedUtxo2.datum.iasset,
+      }),
       expectedResultAdaAmt,
     );
 
     expect(
       assetClassValueOf(adjustedUtxo2.utxo.assets, iassetAc) >=
         robAmtToSpend(
-          adjustedUtxo2.utxo,
-          adjustedUtxo2.datum,
-          sysParams.cdpParams.cdpAssetSymbol,
+          adjustedUtxo2.utxo.assets,
+          adjustedUtxo2.datum.orderType,
+          {
+            currencySymbol: fromHex(
+              sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+            ),
+            tokenName: adjustedUtxo2.datum.iasset,
+          },
         ),
       'IAssets to spend has to equal iassets in UTXO',
     ).toBeTruthy();
@@ -1390,8 +1402,8 @@ describe('ROB', () => {
     const redemptionIAssetAmt = 11_000_000n;
 
     const amtToSpendBefore = robCollateralAmtToSpend(
-      robUtxo.utxo,
-      robUtxo.datum,
+      robUtxo.utxo.assets,
+      robUtxo.datum.orderType,
     );
 
     await runAndAwaitTx(
@@ -1420,7 +1432,10 @@ describe('ROB', () => {
 
     expect(
       amtToSpendBefore -
-        robCollateralAmtToSpend(redeemedRob.utxo, redeemedRob.datum),
+        robCollateralAmtToSpend(
+          redeemedRob.utxo.assets,
+          redeemedRob.datum.orderType,
+        ),
       'ROB has wrong number redeemed',
     ).toEqual(
       // Since price is 1
@@ -1565,7 +1580,10 @@ describe('ROB', () => {
     );
 
     expect(
-      robCollateralAmtToSpend(redeemedRob.utxo, redeemedRob.datum),
+      robCollateralAmtToSpend(
+        redeemedRob.utxo.assets,
+        redeemedRob.datum.orderType,
+      ),
       'Wrong amt to spend in datum',
     ).toEqual(initialDeposit - expectedRedeemedAmt);
 
@@ -1713,11 +1731,12 @@ describe('ROB', () => {
     );
 
     expect(
-      robAmtToSpend(
-        redeemedRob.utxo,
-        redeemedRob.datum,
-        sysParams.cdpParams.cdpAssetSymbol,
-      ),
+      robAmtToSpend(redeemedRob.utxo.assets, redeemedRob.datum.orderType, {
+        currencySymbol: fromHex(
+          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+        ),
+        tokenName: redeemedRob.datum.iasset,
+      }),
       'Wrong amt to spend in datum',
     ).toEqual(initialDeposit - expectedRedemptionAmt);
 
@@ -2223,24 +2242,6 @@ describe('ROB', () => {
 
     const payoutIAssetAmt = 11_000_000n;
 
-    // const expectedRedemptionAmt =(
-    //   {
-    //     getOnChainInt:
-    //       payoutCollateralAmt -
-    //       calculateFeeFromPercentage(
-    //         (
-    //           await findIAssetNew(
-    //             context,
-    //             sysParams,
-    //             iusdAssetInfo.iassetTokenNameAscii,
-    //           )
-    //         ).datum.redemptionReimbursementPercentage,
-    //         payoutCollateralAmt,
-    //       ),
-    //   },
-    //   newPrice,
-    // ).getOnChainInt;
-
     await runAndAwaitTx(
       context.lucid,
       runRedeemRob(
@@ -2290,7 +2291,10 @@ describe('ROB', () => {
 
     // Since price is 1
     expect(
-      robCollateralAmtToSpend(adjustedRob.utxo, adjustedRob.datum),
+      robCollateralAmtToSpend(
+        adjustedRob.utxo.assets,
+        adjustedRob.datum.orderType,
+      ),
     ).toEqual(
       // 20mil start, -1mil adjusted, rest redeemed
       20_000_000n -

package/tests/stability-pool.test.ts

@@ -1924,7 +1924,7 @@ describe('Stability pool', () => {
   });
 
   // These are the most significant tests for benchmarking the maximum number of collateral assets supported.
-  describe('Liquidate', () => {
+  describe.skip('Liquidate', () => {
     test<MyContext>('Liquidate with 10 reward assets in the pool - collecting with 2 assets in treasury', async (context: MyContext) => {
       context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
@@ -2317,7 +2317,7 @@ describe('Stability pool', () => {
       }
     });
 
-    test<MyContext>('Liquidate with 9 reward assets in the pool and increasing epoch', async (context: MyContext) => {
+    test<MyContext>('Liquidate with 10 reward assets in the pool and increasing epoch', async (context: MyContext) => {
       context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
 
       const initialAssets = [
@@ -2330,9 +2330,12 @@ describe('Stability pool', () => {
         collateralAssetF,
         collateralAssetG,
         collateralAssetH,
+        collateralAssetI,
       ];
 
-      expect(initialAssets.length, 'Unexpected reward assets count').toEqual(9);
+      expect(initialAssets.length, 'Unexpected reward assets count').toEqual(
+        10,
+      );
 
       const [sysParams, [iusdAssetInfo]] = await init(
         context.lucid,
@@ -2484,7 +2487,7 @@ describe('Stability pool', () => {
           iusdAssetInfo,
           async (tx) =>
             benchmarkAndAwaitTx(
-              'Stability Pool - Liquidate with 9 reward assets in the pool and increasing epoch',
+              'Stability Pool - Liquidate with 10 reward assets in the pool and increasing epoch',
               tx,
               context.lucid,
               context.emulator,

package/tests/stableswap/stableswap.test.ts

@@ -60,7 +60,7 @@ import { expectScriptFailure } from '../utils/asserts';
 import {
   findRandomTreasuryUtxoWithOnlyAda,
   findRandomTreasuryUtxoWithAsset,
-} from '../queries/treasury-queries';
+} from '../treasury/treasury-queries';
 import { createUtxoAtTreasury } from '../endpoints/treasury';
 import { rationalFromInt, rationalZero } from '../../src/types/rational';
 

package/tests/treasury/actions.ts

@@ -0,0 +1,67 @@
+import { Assets, TxBuilder } from '@lucid-evolution/lucid';
+import { LucidContext } from '../test-helpers';
+import { createUtxoAtTreasury } from '../endpoints/treasury';
+import { SystemParams, treasuryMerge, treasurySplit } from '../../src';
+import { findAllTreasuryUtxos } from './treasury-queries';
+import { assert } from 'vitest';
+
+export async function treasuryMergeTx(
+  context: LucidContext,
+  sysParams: SystemParams,
+  treasuryOutputs: Assets[],
+): Promise<TxBuilder> {
+  for (const output of treasuryOutputs) {
+    await createUtxoAtTreasury(output, sysParams, context);
+  }
+
+  const treasuryUtxos = await findAllTreasuryUtxos(context.lucid, sysParams);
+
+  // Simpler approach: for each expected output in treasuryOutputs, find one UTxO with exactly matching assets and take it
+  // Find UTxOs for each expected output, but remove it from the candidate list as we match
+  const availableUtxos = [...treasuryUtxos];
+  const matchedTreasuryUtxos = treasuryOutputs
+    .map((expectedAssets) => {
+      const idx = availableUtxos.findIndex((utxo) => {
+        const utxoAssets = utxo.assets;
+        const keys1 = Object.keys(utxoAssets).sort();
+        const keys2 = Object.keys(expectedAssets).sort();
+        if (keys1.length !== keys2.length) return false;
+        return keys1.every(
+          (k, i) => k === keys2[i] && utxoAssets[k] === expectedAssets[k],
+        );
+      });
+      if (idx !== -1) {
+        return availableUtxos.splice(idx, 1)[0];
+      } else {
+        return undefined;
+      }
+    })
+    .filter((utxo) => utxo !== undefined);
+
+  assert(
+    matchedTreasuryUtxos.length === treasuryOutputs.length,
+    'Expected all treasury outputs to be matched',
+  );
+
+  return await treasuryMerge(matchedTreasuryUtxos, context.lucid, sysParams);
+}
+
+export async function treasurySplitTx(
+  context: LucidContext,
+  sysParams: SystemParams,
+  treasuryOutput: Assets,
+): Promise<TxBuilder> {
+  await createUtxoAtTreasury(treasuryOutput, sysParams, context);
+
+  const treasuryUtxos = await findAllTreasuryUtxos(context.lucid, sysParams);
+
+  const matchedTreasuryUtxo = treasuryUtxos.find((utxo) =>
+    Object.keys(treasuryOutput).every(
+      (key) => utxo.assets[key] === treasuryOutput[key],
+    ),
+  );
+
+  assert(matchedTreasuryUtxo !== undefined, 'Expected a single treasury UTXO');
+
+  return await treasurySplit(matchedTreasuryUtxo, context.lucid, sysParams);
+}

package/tests/{queries → treasury}/treasury-queries.ts

@@ -1,9 +1,10 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { SystemParams } from '../../src';
+import { fromSystemParamsAsset, SystemParams } from '../../src';
 import { option as O, function as F } from 'fp-ts';
 import {
   AssetClass,
   assetClassToUnit,
+  assetClassValueOf,
   getRandomElement,
 } from '@3rd-eye-labs/cardano-offchain-common';
 
@@ -85,6 +86,7 @@ export async function findAllTreasuryUtxos(
 export async function findAllTreasuryUtxosWithNonAdaAsset(
   lucid: LucidEvolution,
   sysParams: SystemParams,
+  includeDaoToken: boolean = true,
 ): Promise<UTxO[]> {
   // We need to consider both with staking credential and without.
   const treasuryUtxos = await lucid.utxosAt({
@@ -93,7 +95,14 @@ export async function findAllTreasuryUtxosWithNonAdaAsset(
   });
 
   const treasuryUtxosWithNonAdaAsset = treasuryUtxos.filter(
-    (utxo) => Object.keys(utxo.assets).length !== 1,
+    (utxo) =>
+      Object.keys(utxo.assets).length !== 1 &&
+      (includeDaoToken
+        ? true
+        : assetClassValueOf(
+            utxo.assets,
+            fromSystemParamsAsset(sysParams.govParams.daoIdentityToken),
+          ) === 0n),
   );
 
   return treasuryUtxosWithNonAdaAsset;

package/tests/treasury/treasury.test.ts

@@ -0,0 +1,342 @@
+import {
+  addAssets,
+  Emulator,
+  EmulatorAccount,
+  fromHex,
+  fromText,
+  generateEmulatorAccount,
+  Lucid,
+} from '@lucid-evolution/lucid';
+import { beforeEach, describe, test } from 'vitest';
+import { LucidContext } from '../test-helpers';
+import { treasuryCollect } from '../../src';
+import {
+  EXAMPLE_TOKEN_1,
+  EXAMPLE_TOKEN_2,
+  EXAMPLE_TOKEN_3,
+  MAINNET_PROTOCOL_PARAMETERS,
+} from '../indigo-test-helpers';
+import { benchmarkAndAwaitTx } from '../utils/benchmark-utils';
+import { findRandomTreasuryUtxoWithOnlyAda } from './treasury-queries';
+import {
+  adaAssetClass,
+  AssetClass,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
+import { expectScriptFailure } from '../utils/asserts';
+import { treasuryMergeTx, treasurySplitTx } from './actions';
+import { init } from '../endpoints/initialize';
+import { iusdInitialAssetCfg } from '../mock/assets-mock';
+
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+  user: EmulatorAccount;
+  withdrawalAccount: EmulatorAccount;
+}>;
+
+const testAssetA: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8daa',
+  ),
+  tokenName: fromHex(fromText('A')),
+};
+const testAssetB: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dab',
+  ),
+  tokenName: fromHex(fromText('B')),
+};
+
+const testAssetC: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'aa072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dac',
+  ),
+  tokenName: fromHex(fromText('C')),
+};
+
+const testAssetD: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dad',
+  ),
+  tokenName: fromHex(fromText('D')),
+};
+
+const testAssetE: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dae',
+  ),
+  tokenName: fromHex(fromText('E')),
+};
+
+const testAssetF: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8daf',
+  ),
+  tokenName: fromHex(fromText('F')),
+};
+
+const testAssetG: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dba',
+  ),
+  tokenName: fromHex(fromText('G')),
+};
+
+const testAssetH: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbb',
+  ),
+  tokenName: fromHex(fromText('H')),
+};
+
+const testAssetI: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbc',
+  ),
+  tokenName: fromHex(fromText('I')),
+};
+
+const testAssetJ: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbd',
+  ),
+  tokenName: fromHex(fromText('J')),
+};
+
+const testAssetK: AssetClass = {
+  currencySymbol: fromHex(
+    // random generated
+    'cc072059ae741791b7b9c23d9baea6a0b0d764dec617ce7e027a8dbe',
+  ),
+  tokenName: fromHex(fromText('K')),
+};
+
+// NOTE: Withdrawing and PrepareWithdrawal from Treasury is tested in gov.test.ts
+describe('Treasury', () => {
+  beforeEach<MyContext>(async (context: MyContext) => {
+    context.users = {
+      admin: generateEmulatorAccount({
+        lovelace: BigInt(100_000_000_000_000),
+      }),
+      user: generateEmulatorAccount(
+        addAssets(
+          mkLovelacesOf(100_000_000_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_2, 1_000_000_000_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_3, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetA, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetB, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetC, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetD, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetE, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetF, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetG, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetH, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetI, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetJ, 1_000_000_000_000_000n),
+          mkAssetsOf(testAssetK, 1_000_000_000_000_000n),
+        ),
+      ),
+      withdrawalAccount: generateEmulatorAccount({}),
+    };
+
+    context.emulator = new Emulator(
+      [context.users.admin, context.users.user],
+      MAINNET_PROTOCOL_PARAMETERS,
+    );
+    context.lucid = await Lucid(context.emulator, 'Custom');
+  });
+
+  test<MyContext>('Merge (3 lovelace UTxOs)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Merge (3 lovelace UTxOs)',
+      await treasuryMergeTx(context, sysParams, [
+        mkLovelacesOf(50_000_000n),
+        mkLovelacesOf(50_000_000n),
+        mkLovelacesOf(50_000_000n),
+      ]),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Merge (3 INDY UTxOs)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Merge (3 INDY UTxOs)',
+      await treasuryMergeTx(context, sysParams, [
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+      ]),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Merge (fail, 1 lovelace, 2 INDY UTxOs)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await expectScriptFailure(
+      'All inputs have to contain the same merging assets',
+      treasuryMergeTx(context, sysParams, [
+        mkLovelacesOf(5_000_000n),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+      ]),
+    );
+  });
+
+  test<MyContext>('Split (12 assets)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Split (12 assets)',
+      await treasurySplitTx(
+        context,
+        sysParams,
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(testAssetA, 1n),
+          mkAssetsOf(testAssetB, 1n),
+          mkAssetsOf(testAssetC, 1n),
+          mkAssetsOf(testAssetD, 1n),
+          mkAssetsOf(testAssetE, 1n),
+          mkAssetsOf(testAssetF, 1n),
+          mkAssetsOf(testAssetG, 1n),
+          mkAssetsOf(testAssetH, 1n),
+          mkAssetsOf(testAssetI, 1n),
+          mkAssetsOf(testAssetJ, 1n),
+          mkAssetsOf(testAssetK, 1n),
+        ),
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Split (fail, lovelace only)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await expectScriptFailure(
+      'All inputs must have more than 1 non-ADA asset or 1 non-ADA asset and more than 2x ADA buffer',
+      treasurySplitTx(context, sysParams, mkLovelacesOf(5_000_000n)),
+    );
+  });
+
+  test<MyContext>('Collect non-positive amount or negative extra lovelaces fails', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const treasuryUTxO = await findRandomTreasuryUtxoWithOnlyAda(
+      context.lucid,
+      sysParams,
+    );
+
+    // This tests that the amount to collect cannot be negative.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        -1_000_000n,
+        0n,
+        context.lucid,
+        sysParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+
+    // This tests that the amount to collect cannot be zero.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        0n,
+        0n,
+        context.lucid,
+        sysParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+
+    // This tests that the extra lovelaces cannot be negative.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        1n,
+        -1_000_000n,
+        context.lucid,
+        sysParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+  });
+});