@indigo-labs/indigo-sdk 0.3.10 → 0.3.11

package/tests/gov/gov.test.ts

@@ -13,6 +13,7 @@ import {
 } from '@lucid-evolution/lucid';
 import { describe, beforeEach, test, expect, assert } from 'vitest';
 import {
+  adaAssetClass,
   AssetClass,
   assetClassToUnit,
   assetClassValueOf,
@@ -59,7 +60,11 @@ import {
   getNewUtxosAtAddressAfterAction,
   getValueChangeAtAddressAfterAction,
 } from '../utils';
-import { iusdInitialAssetCfg } from '../mock/assets-mock';
+import {
+  iusdInitialAssetCfg,
+  mkBaseCollateralAsset,
+  mkCollateralAssetsChain,
+} from '../mock/assets-mock';
 import { addressFromBech32 } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   EXAMPLE_TOKEN_1,
@@ -97,6 +102,8 @@ import {
 } from '../queries/iasset-queries';
 import { startPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
 import { rationalFromInt, rationalZero } from '../../src/types/rational';
+import { expectScriptFailure } from '../utils/asserts';
+import { MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET } from '../../src/contracts/iasset/helpers';
 
 type MyContext = LucidContext<{
   admin: EmulatorAccount;
@@ -3045,6 +3052,862 @@ describe('Gov', () => {
     });
   });
 
+  test<MyContext>('Execute add (nth - 1) collateral asset proposal (no ADA whitelisted) succeeds', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const initialCollateralAssets = [];
+
+    for (let i = 0; i < MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 2; i++) {
+      const collateralAssetI: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText(i.toString())),
+      };
+      initialCollateralAssets.push(collateralAssetI);
+    }
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: mkCollateralAssetsChain(
+            initialCollateralAssets.map((a) => mkBaseCollateralAsset(a, 0n)),
+          ),
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const [startInterestTx, interestOracleNft] = await startInterestOracle(
+      0n,
+      0n,
+      0n,
+      {
+        biasTime: 120_000n,
+        owner: pkh.hash,
+      },
+      context.lucid,
+    );
+    await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+    const [priceOracleTx, priceOranceNft] = await startPriceOracleTx(
+      context.lucid,
+      'IUSD_INDY_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const collateralAssetN: AssetClass = {
+      currencySymbol: fromHex(
+        '00000000000000000000000000000000000000000000000000000000',
+      ),
+      tokenName: fromHex(
+        fromText(MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET.toString()),
+      ),
+    };
+
+    const [tx, pollId] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: collateralAssetN,
+          assetExtraDecimals: 0n,
+          assetPriceInfo: { OracleNft: priceOranceNft },
+          interestOracleNft: interestOracleNft,
+          redemptionRatio: rationalFromInt(2n),
+          maintenanceRatio: { numerator: 150n, denominator: 100n },
+          liquidationRatio: { numerator: 120n, denominator: 100n },
+          minCollateralAmt: 1_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const iassetOutput = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+      iusdAssetInfo.iassetTokenNameAscii,
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetOutput.utxo,
+        (
+          await findAllCollateralAssetsOfIAsset(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+            fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+          )
+        ).map((o) => o.utxo),
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+
+    const whitelistedCollateralAssets = await findAllCollateralAssetsOfIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+      fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    );
+
+    expect(
+      whitelistedCollateralAssets.length ==
+        MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 1,
+      'Expected different number of whitelisted collateral assets',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute add nth collateral asset proposal (no ADA whitelisted) fails', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const initialCollateralAssets = [];
+
+    for (let i = 0; i < MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 1; i++) {
+      const collateralAssetI: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText(i.toString())),
+      };
+      initialCollateralAssets.push(collateralAssetI);
+    }
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: mkCollateralAssetsChain(
+            initialCollateralAssets.map((a) => mkBaseCollateralAsset(a, 0n)),
+          ),
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const [startInterestTx, interestOracleNft] = await startInterestOracle(
+      0n,
+      0n,
+      0n,
+      {
+        biasTime: 120_000n,
+        owner: pkh.hash,
+      },
+      context.lucid,
+    );
+    await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+    const [priceOracleTx, priceOranceNft] = await startPriceOracleTx(
+      context.lucid,
+      'IUSD_INDY_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    const whitelistedCollateralAssets = await findAllCollateralAssetsOfIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+      fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    );
+
+    expect(
+      whitelistedCollateralAssets.length ==
+        MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 1,
+      'Expected different number of whitelisted collateral assets',
+    ).toBeTruthy();
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const collateralAssetN: AssetClass = {
+      currencySymbol: fromHex(
+        '00000000000000000000000000000000000000000000000000000000',
+      ),
+      tokenName: fromHex(
+        fromText(MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET.toString()),
+      ),
+    };
+
+    const [tx, pollId] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: collateralAssetN,
+          assetExtraDecimals: 0n,
+          assetPriceInfo: { OracleNft: priceOranceNft },
+          interestOracleNft: interestOracleNft,
+          redemptionRatio: rationalFromInt(2n),
+          maintenanceRatio: { numerator: 150n, denominator: 100n },
+          liquidationRatio: { numerator: 120n, denominator: 100n },
+          minCollateralAmt: 1_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const iassetOutput = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+      iusdAssetInfo.iassetTokenNameAscii,
+    );
+
+    await expectScriptFailure(
+      'Max collateral assets reached',
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetOutput.utxo,
+        (
+          await findAllCollateralAssetsOfIAsset(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+            fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+          )
+        ).map((o) => o.utxo),
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  test<MyContext>('Execute add nth collateral asset proposal (ADA whitelisted) succeeds', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const initialCollateralAssets = [adaAssetClass];
+
+    for (let i = 0; i < MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 2; i++) {
+      const collateralAssetI: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText(i.toString())),
+      };
+      initialCollateralAssets.push(collateralAssetI);
+    }
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: mkCollateralAssetsChain(
+            initialCollateralAssets.map((a) => mkBaseCollateralAsset(a, 0n)),
+          ),
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const [startInterestTx, interestOracleNft] = await startInterestOracle(
+      0n,
+      0n,
+      0n,
+      {
+        biasTime: 120_000n,
+        owner: pkh.hash,
+      },
+      context.lucid,
+    );
+    await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+    const [priceOracleTx, priceOranceNft] = await startPriceOracleTx(
+      context.lucid,
+      'IUSD_INDY_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const collateralAssetN: AssetClass = {
+      currencySymbol: fromHex(
+        '00000000000000000000000000000000000000000000000000000000',
+      ),
+      tokenName: fromHex(
+        fromText(MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET.toString()),
+      ),
+    };
+
+    const [tx, pollId] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: collateralAssetN,
+          assetExtraDecimals: 0n,
+          assetPriceInfo: { OracleNft: priceOranceNft },
+          interestOracleNft: interestOracleNft,
+          redemptionRatio: rationalFromInt(2n),
+          maintenanceRatio: { numerator: 150n, denominator: 100n },
+          liquidationRatio: { numerator: 120n, denominator: 100n },
+          minCollateralAmt: 1_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const iassetOutput = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+      iusdAssetInfo.iassetTokenNameAscii,
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetOutput.utxo,
+        (
+          await findAllCollateralAssetsOfIAsset(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+            fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+          )
+        ).map((o) => o.utxo),
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+
+    const whitelistedCollateralAssets = await findAllCollateralAssetsOfIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+      fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    );
+
+    expect(
+      whitelistedCollateralAssets.length ==
+        MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET,
+      'Expected different number of whitelisted collateral assets',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute add ADA collateral asset proposal with (nth - 1) whitelisted assets succeeds', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const initialCollateralAssets = [];
+
+    for (let i = 0; i < MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 1; i++) {
+      const collateralAssetI: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText(i.toString())),
+      };
+      initialCollateralAssets.push(collateralAssetI);
+    }
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: mkCollateralAssetsChain(
+            initialCollateralAssets.map((a) => mkBaseCollateralAsset(a, 0n)),
+          ),
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const [startInterestTx, interestOracleNft] = await startInterestOracle(
+      0n,
+      0n,
+      0n,
+      {
+        biasTime: 120_000n,
+        owner: pkh.hash,
+      },
+      context.lucid,
+    );
+    await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+    const [priceOracleTx, priceOranceNft] = await startPriceOracleTx(
+      context.lucid,
+      'IUSD_INDY_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: adaAssetClass,
+          assetExtraDecimals: 0n,
+          assetPriceInfo: { OracleNft: priceOranceNft },
+          interestOracleNft: interestOracleNft,
+          redemptionRatio: rationalFromInt(2n),
+          maintenanceRatio: { numerator: 150n, denominator: 100n },
+          liquidationRatio: { numerator: 120n, denominator: 100n },
+          minCollateralAmt: 1_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const iassetOutput = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+      iusdAssetInfo.iassetTokenNameAscii,
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetOutput.utxo,
+        (
+          await findAllCollateralAssetsOfIAsset(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+            fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+          )
+        ).map((o) => o.utxo),
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+
+    const whitelistedCollateralAssets = await findAllCollateralAssetsOfIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+      fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    );
+
+    expect(
+      whitelistedCollateralAssets.length ==
+        MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET,
+      'Expected different number of whitelisted collateral assets',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute add (nth + 1) collateral asset proposal (ADA whitelisted) fails', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const initialCollateralAssets = [adaAssetClass];
+
+    for (let i = 0; i < MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET - 1; i++) {
+      const collateralAssetI: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText(i.toString())),
+      };
+      initialCollateralAssets.push(collateralAssetI);
+    }
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [
+        {
+          ...iusdInitialAssetCfg(),
+          collateralAssets: mkCollateralAssetsChain(
+            initialCollateralAssets.map((a) => mkBaseCollateralAsset(a, 0n)),
+          ),
+        },
+      ],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const [startInterestTx, interestOracleNft] = await startInterestOracle(
+      0n,
+      0n,
+      0n,
+      {
+        biasTime: 120_000n,
+        owner: pkh.hash,
+      },
+      context.lucid,
+    );
+    await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+    const [priceOracleTx, priceOranceNft] = await startPriceOracleTx(
+      context.lucid,
+      'IUSD_INDY_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    const whitelistedCollateralAssets = await findAllCollateralAssetsOfIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+      fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+    );
+
+    expect(
+      whitelistedCollateralAssets.length ==
+        MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET,
+      'Expected different number of whitelisted collateral assets',
+    ).toBeTruthy();
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const collateralAssetN: AssetClass = {
+      currencySymbol: fromHex(
+        '00000000000000000000000000000000000000000000000000000000',
+      ),
+      tokenName: fromHex(
+        fromText(MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET.toString()),
+      ),
+    };
+
+    const [tx, pollId] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: collateralAssetN,
+          assetExtraDecimals: 0n,
+          assetPriceInfo: { OracleNft: priceOranceNft },
+          interestOracleNft: interestOracleNft,
+          redemptionRatio: rationalFromInt(2n),
+          maintenanceRatio: { numerator: 150n, denominator: 100n },
+          liquidationRatio: { numerator: 120n, denominator: 100n },
+          minCollateralAmt: 1_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const iassetOutput = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+      iusdAssetInfo.iassetTokenNameAscii,
+    );
+
+    await expectScriptFailure(
+      'Max collateral assets reached',
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetOutput.utxo,
+        (
+          await findAllCollateralAssetsOfIAsset(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+            fromHex(fromText(iusdAssetInfo.iassetTokenNameAscii)),
+          )
+        ).map((o) => o.utxo),
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+  });
+
   test<MyContext>('Execute update collateral asset proposal', async (context: MyContext) => {
     context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);