@indigo-labs/indigo-sdk 0.2.42 → 0.3.1

package/tests/gov/gov.test.ts

@@ -0,0 +1,4450 @@
+import {
+  addAssets,
+  Emulator,
+  EmulatorAccount,
+  generateEmulatorAccount,
+  Lucid,
+  toText,
+  fromHex,
+  fromText,
+  paymentCredentialOf,
+  toHex,
+  unixTimeToSlot,
+} from '@lucid-evolution/lucid';
+import { describe, beforeEach, test, expect, assert } from 'vitest';
+import {
+  AssetClass,
+  assetClassToUnit,
+  assetClassValueOf,
+  isSameAssetClass,
+  mkAssetsOf,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { init } from '../endpoints/initialize';
+import { findGov } from '../gov/governance-queries';
+import {
+  addrDetails,
+  adjustStakingPosition,
+  createProposal,
+  createScriptAddress,
+  createShardsChunks,
+  endProposal,
+  executeProposal,
+  fromSystemParamsAsset,
+  matchSingle,
+  mergeShards,
+  ONE_DAY,
+  openStakingPosition,
+  startInterestOracle,
+  treasuryPrepareWithdrawal,
+  vote,
+} from '../../src';
+
+import {
+  findAllPollShards,
+  findPollManager,
+  findRandomPollShard,
+} from '../queries/poll-queries';
+import { findStakingPosition } from '../queries/staking-queries';
+import {
+  option as O,
+  readonlyArray as RA,
+  task as T,
+  array as A,
+  function as F,
+  number as N,
+} from 'fp-ts';
+import { findExecute } from '../queries/execute-queries';
+import {
+  getNewUtxosAtAddressAfterAction,
+  getValueChangeAtAddressAfterAction,
+} from '../utils';
+import { iusdInitialAssetCfg } from '../mock/assets-mock';
+import { addressFromBech32 } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  EXAMPLE_TOKEN_1,
+  EXAMPLE_TOKEN_2,
+  EXAMPLE_TOKEN_3,
+  MAINNET_PROTOCOL_PARAMETERS,
+} from '../indigo-test-helpers';
+import { benchmarkAndAwaitTx } from '../utils/benchmark-utils';
+import {
+  findAllTreasuryUtxos,
+  findAllTreasuryUtxosWithNonAdaAsset,
+} from '../queries/treasury-queries';
+import {
+  createIndyUtxoAtTreasury,
+  createUtxoAtTreasury,
+} from '../endpoints/treasury';
+import { findRandomCdpCreator, findStableswapPool } from '../cdp/cdp-queries';
+import {
+  runCreateAllShards,
+  runEndProposal,
+  runMergeAllShards,
+  runVote,
+  waitForVotingEnd,
+} from './actions';
+import {
+  LucidContext,
+  runAndAwaitTx,
+  runAndAwaitTxBuilder,
+} from '../test-helpers';
+import {
+  findAllCollateralAssetsOfIAsset,
+  findAllIAssets,
+  findCollateralAssetNew,
+  findIAsset,
+} from '../queries/iasset-queries';
+import { startPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
+import { rationalFromInt, rationalZero } from '../../src/types/rational';
+
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+  user: EmulatorAccount;
+  withdrawalAccount: EmulatorAccount;
+}>;
+
+describe('Gov', () => {
+  beforeEach<MyContext>(async (context: MyContext) => {
+    context.users = {
+      admin: generateEmulatorAccount({
+        lovelace: BigInt(100_000_000_000_000),
+      }),
+      user: generateEmulatorAccount(
+        addAssets(
+          mkLovelacesOf(150_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),
+        ),
+      ),
+      withdrawalAccount: generateEmulatorAccount({}),
+    };
+
+    context.emulator = new Emulator(
+      [context.users.admin, context.users.user],
+      MAINNET_PROTOCOL_PARAMETERS,
+    );
+    context.lucid = await Lucid(context.emulator, 'Custom');
+  });
+
+  test<MyContext>('Create text proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, _] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Create text proposal',
+      tx,
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Create text proposal with shards', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    // Create all shards in one transaction.
+    {
+      const govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const pollUtxo = await findPollManager(
+        context.lucid,
+        sysParams.validatorHashes.pollManagerHash,
+        fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+        pollId,
+      );
+
+      await benchmarkAndAwaitTx(
+        `Gov - Create ${govUtxo.datum.protocolParams.totalShards} shards`,
+        await createShardsChunks(
+          govUtxo.datum.protocolParams.totalShards,
+          pollUtxo.utxo,
+          sysParams,
+          context.emulator.slot,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+    }
+
+    const pollUtxo = await findPollManager(
+      context.lucid,
+      sysParams.validatorHashes.pollManagerHash,
+      fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+      pollId,
+    );
+
+    expect(
+      pollUtxo.datum.createdShardsCount === pollUtxo.datum.totalShardsCount,
+      'Expected total shards count being created',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Merge proposal shards', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    {
+      const pollUtxo = await findPollManager(
+        context.lucid,
+        sysParams.validatorHashes.pollManagerHash,
+        fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+        pollId,
+      );
+
+      await runAndAwaitTx(
+        context.lucid,
+        createShardsChunks(
+          2n,
+          pollUtxo.utxo,
+          sysParams,
+          context.emulator.slot,
+          context.lucid,
+        ),
+      );
+
+      const targetSlot = unixTimeToSlot(
+        context.lucid.config().network!,
+        Number(pollUtxo.datum.votingEndTime),
+      );
+      expect(targetSlot).toBeGreaterThan(context.emulator.slot);
+
+      context.emulator.awaitSlot(targetSlot - context.emulator.slot + 1);
+    }
+
+    {
+      const pollUtxo = await findPollManager(
+        context.lucid,
+        sysParams.validatorHashes.pollManagerHash,
+        fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+        pollId,
+      );
+
+      const allPollShards = await findAllPollShards(
+        context.lucid,
+        sysParams.validatorHashes.pollShardHash,
+        fromSystemParamsAsset(sysParams.pollShardParams.pollToken),
+        pollUtxo.datum.pollId,
+      );
+
+      assert(allPollShards.length === 2);
+
+      await benchmarkAndAwaitTx(
+        `Gov - Merge ${allPollShards.length} shards`,
+        await mergeShards(
+          pollUtxo.utxo,
+          allPollShards.map((u) => u.utxo),
+          sysParams,
+          context.lucid,
+          context.emulator.slot,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+    }
+
+    const pollUtxo = await findPollManager(
+      context.lucid,
+      sysParams.validatorHashes.pollManagerHash,
+      fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+      pollId,
+    );
+
+    assert(pollUtxo.datum.talliedShardsCount === 2n);
+  });
+
+  test<MyContext>('Create propose iasset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, ___] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, __] = await createProposal(
+      {
+        ProposeIAsset: {
+          asset: fromHex(fromText('iBTC')),
+          debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+          stabilityPoolWithdrawalFeeRatio: {
+            numerator: 5n,
+            denominator: 1_000n,
+          },
+          redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+          redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Create iasset proposal',
+      tx,
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Create modify iasset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, ___] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, __] = await createProposal(
+      {
+        ModifyIAsset: {
+          asset: fromHex(fromText('iBTC')),
+          newDebtMintingFeeRatio: rationalZero,
+          newLiquidationProcessingFeeRatio: {
+            numerator: 2n,
+            denominator: 100n,
+          },
+          newStabilityPoolWithdrawalFeeRatio: {
+            numerator: 5n,
+            denominator: 1_000n,
+          },
+          newRedemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+          newRedemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Create modify iasset proposal',
+      tx,
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Create add collateral asset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      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 govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, __] = await createProposal(
+      {
+        AddCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: fromSystemParamsAsset(sysParams.govParams.indyAsset),
+          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 benchmarkAndAwaitTx(
+      'Gov - Create collateral asset proposal',
+      tx,
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Create update collateral asset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      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,
+      'NEW_IUSD_ADA_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, __] = await createProposal(
+      {
+        UpdateCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: iusdAssetInfo.collateralAssets[0].collateralAsset,
+          newAssetExtraDecimals: 0n,
+          newAssetPriceInfo: { OracleNft: priceOranceNft },
+          newInterestOracleNft: interestOracleNft,
+          newLiquidationRatio: { numerator: 120n, denominator: 100n },
+          newMaintenanceRatio: { numerator: 150n, denominator: 100n },
+          newRedemptionRatio: { numerator: 150n, denominator: 100n },
+          newMinCollateralAmt: 10_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Create update collateral asset proposal',
+      tx,
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Vote on proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(1_000_000n, sysParams, context.lucid),
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const stakingPosOref = await findStakingPosition(
+      context.lucid,
+      sysParams.validatorHashes.stakingHash,
+      fromSystemParamsAsset(sysParams.stakingParams.stakingToken),
+      pkh.hash,
+    );
+
+    const pollShard = await findRandomPollShard(
+      context.lucid,
+      sysParams.validatorHashes.pollShardHash,
+      fromSystemParamsAsset(sysParams.pollShardParams.pollToken),
+      pollId,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Vote on proposal',
+      await vote(
+        'Yes',
+        pollShard.utxo,
+        stakingPosOref.utxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Vote on proposal, then deposit more INDY', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(1_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    const [pkh, _skh] = await addrDetails(context.lucid);
+    const stakingPosUtxo = await findStakingPosition(
+      context.lucid,
+      sysParams.validatorHashes.stakingHash,
+      fromSystemParamsAsset(sysParams.stakingParams.stakingToken),
+      pkh.hash,
+    );
+
+    context.emulator.awaitSlot(60);
+
+    await runAndAwaitTx(
+      context.lucid,
+      adjustStakingPosition(
+        stakingPosUtxo.utxo,
+        500_000_000n,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  test<MyContext>('Vote on 2 proposals sequentially (lower pollID first)', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(1_000_000n, sysParams, context.lucid),
+    );
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    // Create proposals
+    const createProposalsTask = F.pipe(
+      [fromHex(fromText('proposal 1')), fromHex(fromText('proposal 2'))].map(
+        (txtContent): T.Task<bigint> => {
+          return async () => {
+            const govUtxo = await findGov(
+              context.lucid,
+              sysParams.validatorHashes.govHash,
+              fromSystemParamsAsset(sysParams.govParams.govNFT),
+            );
+
+            const [tx, pollId] = await createProposal(
+              { TextProposal: txtContent },
+              null,
+              sysParams,
+              context.lucid,
+              context.emulator.slot,
+              govUtxo.utxo,
+              [],
+            );
+
+            await runAndAwaitTxBuilder(context.lucid, tx);
+
+            await runCreateAllShards(pollId, sysParams, context);
+
+            return pollId;
+          };
+        },
+      ),
+      T.sequenceSeqArray,
+    );
+
+    const pollIds = await createProposalsTask();
+
+    // vote on each proposal
+    const voteEachProposalTask = F.pipe(
+      pollIds.map(
+        (pollId): T.Task<void> =>
+          async () => {
+            await runVote(
+              pollId,
+              Number(pollId) % 2 == 0 ? 'Yes' : 'No',
+              sysParams,
+              context,
+            );
+          },
+      ),
+      T.sequenceSeqArray,
+    );
+
+    await voteEachProposalTask();
+
+    const stakingPosUtxo = await findStakingPosition(
+      context.lucid,
+      sysParams.validatorHashes.stakingHash,
+      fromSystemParamsAsset(sysParams.stakingParams.stakingToken),
+      pkh.hash,
+    );
+
+    expect([...stakingPosUtxo.datum.lockedAmount.map((x) => x[0])]).toEqual([
+      1n,
+      2n,
+    ]);
+  });
+
+  test<MyContext>('Vote on 2 proposals in reverse (higher pollID first), both yes and no votes', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(1_000_000n, sysParams, context.lucid),
+    );
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    // Create proposals
+    const createProposalsTask = F.pipe(
+      [fromHex(fromText('proposal 1')), fromHex(fromText('proposal 2'))].map(
+        (txtContent): T.Task<bigint> => {
+          return async () => {
+            const govUtxo = await findGov(
+              context.lucid,
+              sysParams.validatorHashes.govHash,
+              fromSystemParamsAsset(sysParams.govParams.govNFT),
+            );
+
+            const [tx, pollId] = await createProposal(
+              { TextProposal: txtContent },
+              null,
+              sysParams,
+              context.lucid,
+              context.emulator.slot,
+              govUtxo.utxo,
+              [],
+            );
+
+            await runAndAwaitTxBuilder(context.lucid, tx);
+
+            await runCreateAllShards(pollId, sysParams, context);
+
+            return pollId;
+          };
+        },
+      ),
+      T.sequenceSeqArray,
+    );
+
+    const pollIdsDescending = F.pipe(
+      await createProposalsTask(),
+      RA.toArray, // Sort it from high to low
+      A.map(Number),
+      A.sort(N.Ord),
+      A.map(BigInt),
+      A.reverse,
+    );
+
+    // vote on each proposal
+    const voteEachProposalTask = F.pipe(
+      pollIdsDescending.map(
+        (pollId): T.Task<void> =>
+          async () => {
+            await runVote(
+              pollId,
+              Number(pollId) % 2 == 0 ? 'Yes' : 'No',
+              sysParams,
+              context,
+            );
+          },
+      ),
+      T.sequenceSeqArray,
+    );
+
+    await voteEachProposalTask();
+
+    const stakingPosUtxo = await findStakingPosition(
+      context.lucid,
+      sysParams.validatorHashes.stakingHash,
+      fromSystemParamsAsset(sysParams.stakingParams.stakingToken),
+      pkh.hash,
+    );
+
+    expect([...stakingPosUtxo.datum.lockedAmount.map((x) => x[0])]).toEqual([
+      2n,
+      1n,
+    ]);
+  });
+
+  test<MyContext>('End passed proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    {
+      const pollUtxo = await findPollManager(
+        context.lucid,
+        sysParams.validatorHashes.pollManagerHash,
+        fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+        pollId,
+      );
+
+      const govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      await benchmarkAndAwaitTx(
+        'Gov - End proposal',
+        await endProposal(
+          pollUtxo.utxo,
+          govUtxo.utxo,
+          sysParams,
+          context.lucid,
+          context.emulator.slot,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+    }
+
+    await expect(
+      findExecute(
+        context.lucid,
+        sysParams.validatorHashes.executeHash,
+        fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+        pollId,
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  test<MyContext>('End failed proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'No', sysParams, context);
+
+    {
+      const pollUtxo = await findPollManager(
+        context.lucid,
+        sysParams.validatorHashes.pollManagerHash,
+        fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+        pollId,
+      );
+
+      const targetSlot = unixTimeToSlot(
+        context.lucid.config().network!,
+        Number(pollUtxo.datum.votingEndTime),
+      );
+      expect(targetSlot).toBeGreaterThan(context.emulator.slot);
+
+      context.emulator.awaitSlot(targetSlot - context.emulator.slot + 1);
+    }
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    const pollUtxo = await findPollManager(
+      context.lucid,
+      sysParams.validatorHashes.pollManagerHash,
+      fromSystemParamsAsset(sysParams.pollManagerParams.pollToken),
+      pollId,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [_, newUtxos] = await getNewUtxosAtAddressAfterAction(
+      context.lucid,
+      createScriptAddress(
+        context.lucid.config().network!,
+        sysParams.validatorHashes.treasuryHash,
+      ),
+      async () =>
+        benchmarkAndAwaitTx(
+          'Gov - End failed proposal',
+          await endProposal(
+            pollUtxo.utxo,
+            govUtxo.utxo,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    const treasuryOutput = matchSingle(
+      newUtxos,
+      () => new Error('Expected single treasury output'),
+    );
+
+    assert(
+      assetClassValueOf(
+        treasuryOutput.assets,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === govUtxo.datum.protocolParams.proposalDeposit,
+      'Treasury should get proposal deposit back on failed proposal end',
+    );
+
+    await expect(
+      findExecute(
+        context.lucid,
+        sysParams.validatorHashes.executeHash,
+        fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+        pollId,
+      ),
+    ).rejects.toThrow();
+  });
+
+  test<MyContext>('Execute text proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute text proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        govUtxo.utxo,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute text proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    const [_, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        await benchmarkAndAwaitTx(
+          'Execute text proposal with treasury withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            govUtxo.utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            null,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute text proposal with treasury withdrawal with Treasury PrepareWithdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, __] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+    const withdrawalAmt = 2n;
+
+    await createUtxoAtTreasury(
+      mkAssetsOf(EXAMPLE_TOKEN_1, 5n),
+      sysParams,
+      context,
+    );
+    await createUtxoAtTreasury(
+      mkAssetsOf(EXAMPLE_TOKEN_2, 5n),
+      sysParams,
+      context,
+    );
+
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [tx, pollId] = await createProposal(
+      { TextProposal: fromHex(fromText('smth')) },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            ...EXAMPLE_TOKEN_1,
+            amount: withdrawalAmt,
+          },
+          { ...EXAMPLE_TOKEN_2, amount: withdrawalAmt },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId, sysParams, context);
+
+    await runMergeAllShards(pollId, sysParams, context);
+
+    await runEndProposal(pollId, sysParams, context);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+    const executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId,
+    );
+
+    // One UTxO with the DAO token, five ADA only UTxOs and
+    // one UTxO with EXAMPLE_TOKEN_1 and one with EXAMPLE_TOKEN_2.
+    assert(
+      (await findAllTreasuryUtxos(context.lucid, sysParams)).length === 8,
+      'Expected 8 treasury withdrawal UTXOs prior to prepare withdrawal',
+    );
+
+    // Prepare withdrawal
+    await runAndAwaitTx(
+      context.lucid,
+      treasuryPrepareWithdrawal(
+        await findAllTreasuryUtxosWithNonAdaAsset(context.lucid, sysParams),
+        executeUtxo.utxo,
+        context.lucid,
+        sysParams,
+      ),
+    );
+
+    const treasuryWithdrawalUtxos = await findAllTreasuryUtxos(
+      context.lucid,
+      sysParams,
+    );
+
+    // One with the value to withdraw and one UTxO with the change, plus five ADA only UTxOs.
+    assert(
+      treasuryWithdrawalUtxos.length === 7,
+      'Expected 7 treasury withdrawal UTXOs',
+    );
+
+    const treasuryWithdrawalUtxo = matchSingle(
+      treasuryWithdrawalUtxos.filter(
+        (utxo) =>
+          utxo.assets[assetClassToUnit(EXAMPLE_TOKEN_1)] === withdrawalAmt,
+      ),
+      () => new Error('Expected a single treasury withdrawal UTXO'),
+    );
+
+    const [_, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        await runAndAwaitTx(
+          context.lucid,
+          executeProposal(
+            executeUtxo.utxo,
+            govUtxo.utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            null,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+        ),
+    );
+
+    expect(
+      assetClassValueOf(newVal, EXAMPLE_TOKEN_1) === withdrawalAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute create IAsset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ProposeIAsset: {
+          asset: fromHex(fromText('iBTC')),
+          debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+          stabilityPoolWithdrawalFeeRatio: {
+            numerator: 5n,
+            denominator: 1_000n,
+          },
+          redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+          redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute create IAsset proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        (
+          await findAllIAssets(
+            context.lucid,
+            sysParams.validatorHashes.iassetHash,
+            fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+          )
+        ).map((iasset) => iasset.utxo),
+        null,
+        null,
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute create asset proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ProposeIAsset: {
+          asset: fromHex(fromText('iBTC')),
+          debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          liquidationProcessingFeeRatio: { numerator: 2n, denominator: 100n },
+          stabilityPoolWithdrawalFeeRatio: {
+            numerator: 5n,
+            denominator: 1_000n,
+          },
+          redemptionReimbursementRatio: { numerator: 1n, denominator: 100n },
+          redemptionProcessingFeeRatio: { numerator: 1n, denominator: 100n },
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 [__, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        benchmarkAndAwaitTx(
+          'Execute create asset proposal with treasury withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            (
+              await findGov(
+                context.lucid,
+                sysParams.validatorHashes.govHash,
+                fromSystemParamsAsset(sysParams.govParams.govNFT),
+              )
+            ).utxo,
+            treasuryWithdrawalUtxo,
+            (
+              await findAllIAssets(
+                context.lucid,
+                sysParams.validatorHashes.iassetHash,
+                fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+              )
+            ).map((iasset) => iasset.utxo),
+            null,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute modify asset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const iassetToModify = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ModifyIAsset: {
+          asset: fromHex(fromText('iUSD')),
+          newDebtMintingFeeRatio: iassetToModify.datum.debtMintingFeeRatio,
+          newLiquidationProcessingFeeRatio:
+            iassetToModify.datum.liquidationProcessingFeeRatio,
+          newStabilityPoolWithdrawalFeeRatio:
+            iassetToModify.datum.stabilityPoolWithdrawalFeeRatio,
+          newRedemptionReimbursementRatio:
+            iassetToModify.datum.redemptionReimbursementRatio,
+          newRedemptionProcessingFeeRatio:
+            iassetToModify.datum.redemptionProcessingFeeRatio,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Execute modify asset proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetToModify.utxo,
+        null,
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute modify asset proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const iassetToModify = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ModifyIAsset: {
+          asset: fromHex(fromText('iUSD')),
+          newDebtMintingFeeRatio: iassetToModify.datum.debtMintingFeeRatio,
+          newLiquidationProcessingFeeRatio:
+            iassetToModify.datum.liquidationProcessingFeeRatio,
+          newStabilityPoolWithdrawalFeeRatio:
+            iassetToModify.datum.stabilityPoolWithdrawalFeeRatio,
+          newRedemptionReimbursementRatio:
+            iassetToModify.datum.redemptionReimbursementRatio,
+          newRedemptionProcessingFeeRatio:
+            iassetToModify.datum.redemptionProcessingFeeRatio,
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 [__, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        benchmarkAndAwaitTx(
+          'Gov - Execute modify asset proposal with treasury withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            (
+              await findGov(
+                context.lucid,
+                sysParams.validatorHashes.govHash,
+                fromSystemParamsAsset(sysParams.govParams.govNFT),
+              )
+            ).utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            iassetToModify.utxo,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  describe('Add collateral asset proposal', () => {
+    test<MyContext>('Execute add collateral asset proposal (no collateral assets on the iassets)', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const collateralAsset1: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('ABC')),
+      };
+
+      const [sysParams, [iusdAssetInfo]] = await init(
+        context.lucid,
+        [
+          {
+            ...iusdInitialAssetCfg(),
+            collateralAssets: [],
+          },
+        ],
+        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 govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const allIassetOrefs = (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo);
+
+      const [tx, pollId] = await createProposal(
+        {
+          AddCollateralAsset: {
+            correspondingIAsset: fromHex(
+              fromText(iusdAssetInfo.iassetTokenNameAscii),
+            ),
+            collateralAsset: collateralAsset1,
+            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 runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      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 benchmarkAndAwaitTx(
+        'Gov - Execute add collateral asset proposal (no collateral assets on the iasset)',
+        await 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,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+
+      const res = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset1,
+      );
+
+      expect(
+        res.datum.firstCollateralAsset,
+        'Expected this collateral asset to become first',
+      ).toBeTruthy();
+
+      expect(
+        F.pipe(
+          res.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            () => true,
+            // There shouldn't be any next collateral asset.
+            (_) => false,
+          ),
+        ),
+        'Expected no next collateral asset',
+      ).toBeTruthy();
+    });
+
+    test<MyContext>('Execute add collateral asset proposal (start of the collateral asset chain)', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const collateralAsset1: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('B')),
+      };
+      const collateralAsset2: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('A')),
+      };
+
+      const [sysParams, [iusdAssetInfo]] = await init(
+        context.lucid,
+        [
+          {
+            ...iusdInitialAssetCfg(),
+            collateralAssets: [
+              {
+                ...iusdInitialAssetCfg().collateralAssets[0],
+                collateralAsset: collateralAsset1,
+              },
+            ],
+          },
+        ],
+        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 govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const allIassetOrefs = (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo);
+
+      const [tx, pollId] = await createProposal(
+        {
+          AddCollateralAsset: {
+            correspondingIAsset: fromHex(
+              fromText(iusdAssetInfo.iassetTokenNameAscii),
+            ),
+            collateralAsset: collateralAsset2,
+            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 runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      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 benchmarkAndAwaitTx(
+        'Gov - Execute add collateral asset proposal (start of the collateral asset chain)',
+        await 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,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+
+      const res = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset2,
+      );
+
+      expect(
+        res.datum.firstCollateralAsset,
+        'Expected this collateral asset to become first',
+      ).toBeTruthy();
+
+      expect(
+        F.pipe(
+          res.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            // There should be some next collateral asset
+            () => false,
+            (next) => isSameAssetClass(next, collateralAsset1),
+          ),
+        ),
+        'Expected correct next collateral asset',
+      ).toBeTruthy();
+    });
+
+    test<MyContext>('Execute add collateral asset proposal (middle of the collateral asset chain)', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const collateralAsset1: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('A')),
+      };
+      const collateralAsset2: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('B')),
+      };
+      const collateralAsset3: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('C')),
+      };
+
+      const [sysParams, [iusdAssetInfo]] = await init(
+        context.lucid,
+        [
+          {
+            ...iusdInitialAssetCfg(),
+            collateralAssets: [
+              {
+                ...iusdInitialAssetCfg().collateralAssets[0],
+                collateralAsset: collateralAsset1,
+                nextCollateralAsset: collateralAsset3,
+              },
+              {
+                ...iusdInitialAssetCfg().collateralAssets[0],
+                collateralAsset: collateralAsset3,
+              },
+            ],
+          },
+        ],
+        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 govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const allIassetOrefs = (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo);
+
+      const [tx, pollId] = await createProposal(
+        {
+          AddCollateralAsset: {
+            correspondingIAsset: fromHex(
+              fromText(iusdAssetInfo.iassetTokenNameAscii),
+            ),
+            collateralAsset: collateralAsset2,
+            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 runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      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 benchmarkAndAwaitTx(
+        'Gov - Execute add collateral asset proposal (middle of the collateral asset chain)',
+        await 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,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+
+      const newCollateralAsset = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset2,
+      );
+      const collateralAssetFirst = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset1,
+      );
+
+      expect(
+        collateralAssetFirst.datum.firstCollateralAsset,
+        'Expected this collateral asset to BE first',
+      ).toBeTruthy();
+
+      expect(
+        F.pipe(
+          collateralAssetFirst.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            // There should be some next collateral asset
+            () => false,
+            (next) => isSameAssetClass(next, collateralAsset2),
+          ),
+        ),
+        'Expected correct next collateral asset on the first collateral asset',
+      ).toBeTruthy();
+
+      expect(
+        newCollateralAsset.datum.firstCollateralAsset,
+        'Expected this collateral asset to NOT BE first',
+      ).toBeFalsy();
+
+      expect(
+        F.pipe(
+          newCollateralAsset.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            // There should be some next collateral asset
+            () => false,
+            (next) => isSameAssetClass(next, collateralAsset3),
+          ),
+        ),
+        'Expected correct next collateral asset on the new collateral asset',
+      ).toBeTruthy();
+    });
+
+    test<MyContext>('Execute add collateral asset proposal (end of the collateral asset chain)', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const collateralAsset1: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('A')),
+      };
+      const collateralAsset2: AssetClass = {
+        currencySymbol: fromHex(
+          '00000000000000000000000000000000000000000000000000000000',
+        ),
+        tokenName: fromHex(fromText('B')),
+      };
+
+      const [sysParams, [iusdAssetInfo]] = await init(
+        context.lucid,
+        [
+          {
+            ...iusdInitialAssetCfg(),
+            collateralAssets: [
+              {
+                ...iusdInitialAssetCfg().collateralAssets[0],
+                collateralAsset: collateralAsset1,
+              },
+            ],
+          },
+        ],
+        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 govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const allIassetOrefs = (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo);
+
+      const [tx, pollId] = await createProposal(
+        {
+          AddCollateralAsset: {
+            correspondingIAsset: fromHex(
+              fromText(iusdAssetInfo.iassetTokenNameAscii),
+            ),
+            collateralAsset: collateralAsset2,
+            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 runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      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 benchmarkAndAwaitTx(
+        'Gov - Execute add collateral asset proposal (end of the collateral asset chain)',
+        await 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,
+        ),
+        context.lucid,
+        context.emulator,
+      );
+
+      const newCollateralAsset = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset2,
+      );
+      const collateralAssetFirst = await findCollateralAssetNew(
+        context,
+        sysParams,
+        iusdAssetInfo.iassetTokenNameAscii,
+        collateralAsset1,
+      );
+
+      expect(
+        collateralAssetFirst.datum.firstCollateralAsset,
+        'Expected this collateral asset to BE first',
+      ).toBeTruthy();
+
+      expect(
+        F.pipe(
+          collateralAssetFirst.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            // There should be some next collateral asset
+            () => false,
+            (next) => isSameAssetClass(next, collateralAsset2),
+          ),
+        ),
+        'Expected correct next collateral asset on the first collateral asset',
+      ).toBeTruthy();
+
+      expect(
+        newCollateralAsset.datum.firstCollateralAsset,
+        'Expected this collateral asset to NOT BE first',
+      ).toBeFalsy();
+
+      expect(
+        F.pipe(
+          newCollateralAsset.datum.nextCollateralAsset,
+          O.fromNullable,
+          O.match(
+            () => true,
+            // There should be no next collateral asset
+            (_) => false,
+          ),
+        ),
+        'Expected no next collateral asset on the new collateral asset',
+      ).toBeTruthy();
+    });
+
+    test<MyContext>('Execute add iasset and add collateral asset proposals in parallel (execute iasset first, then collateral asset)', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const [sysParams, _] = await init(
+        context.lucid,
+        [iusdInitialAssetCfg()],
+        context.emulator.slot,
+      );
+
+      const [pkh, __] = await addrDetails(context.lucid);
+
+      const createIAssetProposal = async (
+        iassetName: Uint8Array<ArrayBufferLike>,
+      ): Promise<bigint> => {
+        const govUtxo = await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        );
+
+        const [tx, pollId] = await createProposal(
+          {
+            ProposeIAsset: {
+              asset: iassetName,
+              debtMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+              liquidationProcessingFeeRatio: {
+                numerator: 2n,
+                denominator: 100n,
+              },
+              stabilityPoolWithdrawalFeeRatio: {
+                numerator: 5n,
+                denominator: 1_000n,
+              },
+              redemptionReimbursementRatio: {
+                numerator: 1n,
+                denominator: 100n,
+              },
+              redemptionProcessingFeeRatio: {
+                numerator: 1n,
+                denominator: 100n,
+              },
+            },
+          },
+          null,
+          sysParams,
+          context.lucid,
+          context.emulator.slot,
+          govUtxo.utxo,
+          (
+            await findAllIAssets(
+              context.lucid,
+              sysParams.validatorHashes.iassetHash,
+              fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+            )
+          ).map((iasset) => iasset.utxo),
+        );
+
+        await runAndAwaitTxBuilder(context.lucid, tx);
+
+        return pollId;
+      };
+
+      const createCollateralAssetProposal = async (
+        iassetName: Uint8Array<ArrayBufferLike>,
+        collateralAset: AssetClass,
+      ): Promise<bigint> => {
+        const [startInterestTx, interestOracleNft] = await startInterestOracle(
+          0n,
+          0n,
+          0n,
+          {
+            biasTime: 120_000n,
+            owner: pkh.hash,
+          },
+          context.lucid,
+        );
+        await runAndAwaitTxBuilder(context.lucid, startInterestTx);
+
+        const [priceOracleTx, priceOracleNft] = await startPriceOracleTx(
+          context.lucid,
+          'SOME_ORACLE',
+          rationalFromInt(1n),
+          { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+          context.emulator.slot,
+        );
+        await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+        const govUtxo = await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        );
+
+        const [tx, pollId] = await createProposal(
+          {
+            AddCollateralAsset: {
+              correspondingIAsset: iassetName,
+              collateralAsset: collateralAset,
+              assetExtraDecimals: 0n,
+              assetPriceInfo: { OracleNft: priceOracleNft },
+              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,
+          [],
+        );
+
+        await runAndAwaitTxBuilder(context.lucid, tx);
+
+        return pollId;
+      };
+
+      const newIAsset = fromHex(fromText('iBTC'));
+      const newCollateralAsset = fromSystemParamsAsset(
+        sysParams.govParams.indyAsset,
+      );
+
+      const createIAssetPollId = await createIAssetProposal(newIAsset);
+      await runCreateAllShards(createIAssetPollId, sysParams, context);
+
+      const addCollateralAssetPollId = await createCollateralAssetProposal(
+        newIAsset,
+        newCollateralAsset,
+      );
+      await runCreateAllShards(addCollateralAssetPollId, sysParams, context);
+
+      await runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      await runVote(createIAssetPollId, 'Yes', sysParams, context);
+      await runVote(addCollateralAssetPollId, 'Yes', sysParams, context);
+
+      await waitForVotingEnd(createIAssetPollId, sysParams, context);
+      await waitForVotingEnd(addCollateralAssetPollId, sysParams, context);
+
+      await runMergeAllShards(createIAssetPollId, sysParams, context);
+      await runMergeAllShards(addCollateralAssetPollId, sysParams, context);
+
+      await runEndProposal(createIAssetPollId, sysParams, context);
+      await runEndProposal(addCollateralAssetPollId, sysParams, context);
+
+      // Execute the iasset proposal
+      await runAndAwaitTx(
+        context.lucid,
+        executeProposal(
+          (
+            await findExecute(
+              context.lucid,
+              sysParams.validatorHashes.executeHash,
+              fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+              createIAssetPollId,
+            )
+          ).utxo,
+          (
+            await findGov(
+              context.lucid,
+              sysParams.validatorHashes.govHash,
+              fromSystemParamsAsset(sysParams.govParams.govNFT),
+            )
+          ).utxo,
+          null,
+          (
+            await findAllIAssets(
+              context.lucid,
+              sysParams.validatorHashes.iassetHash,
+              fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+            )
+          ).map((iasset) => iasset.utxo),
+          null,
+          null,
+          null,
+          null,
+          sysParams,
+          context.lucid,
+          context.emulator.slot,
+        ),
+      );
+
+      // Execute the add collateral asset proposal
+      await runAndAwaitTx(
+        context.lucid,
+        executeProposal(
+          (
+            await findExecute(
+              context.lucid,
+              sysParams.validatorHashes.executeHash,
+              fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+              addCollateralAssetPollId,
+            )
+          ).utxo,
+          (
+            await findGov(
+              context.lucid,
+              sysParams.validatorHashes.govHash,
+              fromSystemParamsAsset(sysParams.govParams.govNFT),
+            )
+          ).utxo,
+          null,
+          null,
+          (
+            await findIAsset(
+              context.lucid,
+              sysParams.validatorHashes.iassetHash,
+              fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
+              toText(toHex(newIAsset)),
+            )
+          ).utxo,
+          (
+            await findAllCollateralAssetsOfIAsset(
+              context.lucid,
+              sysParams.validatorHashes.iassetHash,
+              fromSystemParamsAsset(
+                sysParams.executeParams.collateralAssetToken,
+              ),
+              newIAsset,
+            )
+          ).map((o) => o.utxo),
+          null,
+          null,
+          sysParams,
+          context.lucid,
+          context.emulator.slot,
+        ),
+      );
+    });
+
+    test<MyContext>('Execute add collateral asset proposal with treasury withdrawal', async (context: MyContext) => {
+      context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+      const [sysParams, [iusdAssetInfo]] = await init(
+        context.lucid,
+        [iusdInitialAssetCfg()],
+        context.emulator.slot,
+      );
+
+      const withdrawalIndyAmt = 1_000n;
+      const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+        withdrawalIndyAmt,
+        sysParams,
+        context,
+      );
+
+      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, priceOracleNft] = 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 govUtxo = await findGov(
+        context.lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      );
+
+      const allIassetOrefs = (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo);
+
+      const [tx, pollId] = await createProposal(
+        {
+          AddCollateralAsset: {
+            correspondingIAsset: fromHex(
+              fromText(iusdAssetInfo.iassetTokenNameAscii),
+            ),
+            collateralAsset: fromSystemParamsAsset(
+              sysParams.govParams.indyAsset,
+            ),
+            assetExtraDecimals: 0n,
+            assetPriceInfo: { OracleNft: priceOracleNft },
+            interestOracleNft: interestOracleNft,
+            redemptionRatio: rationalFromInt(2n),
+            maintenanceRatio: { numerator: 150n, denominator: 100n },
+            liquidationRatio: { numerator: 120n, denominator: 100n },
+            minCollateralAmt: 1_000_000n,
+          },
+        },
+        {
+          destination: addressFromBech32(
+            context.users.withdrawalAccount.address,
+          ),
+          value: [
+            {
+              currencySymbol: fromHex(
+                sysParams.govParams.indyAsset[0].unCurrencySymbol,
+              ),
+              tokenName: fromHex(
+                fromText(sysParams.govParams.indyAsset[1].unTokenName),
+              ),
+              amount: withdrawalIndyAmt,
+            },
+          ],
+        },
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+        govUtxo.utxo,
+        allIassetOrefs,
+      );
+
+      await runAndAwaitTxBuilder(context.lucid, tx);
+
+      await runCreateAllShards(pollId, sysParams, context);
+
+      await runAndAwaitTx(
+        context.lucid,
+        openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+      );
+
+      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,
+      );
+
+      const [__, newVal] = await getValueChangeAtAddressAfterAction(
+        context.lucid,
+        context.users.withdrawalAccount.address,
+        async () =>
+          await benchmarkAndAwaitTx(
+            'Gov - Execute add collateral asset proposal with treasury withdrawal',
+            await executeProposal(
+              executeUtxo.utxo,
+              (
+                await findGov(
+                  context.lucid,
+                  sysParams.validatorHashes.govHash,
+                  fromSystemParamsAsset(sysParams.govParams.govNFT),
+                )
+              ).utxo,
+              treasuryWithdrawalUtxo,
+              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,
+            ),
+            context.lucid,
+            context.emulator,
+          ),
+      );
+
+      expect(
+        assetClassValueOf(
+          newVal,
+          fromSystemParamsAsset(sysParams.govParams.indyAsset),
+        ) === withdrawalIndyAmt,
+        'Unexpected withdrawn indy amt',
+      ).toBeTruthy();
+    });
+  });
+
+  test<MyContext>('Execute update collateral asset proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      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,
+      'NEW_IUSD_ADA_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, pollId] = await createProposal(
+      {
+        UpdateCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: iusdAssetInfo.collateralAssets[0].collateralAsset,
+          newAssetExtraDecimals: 0n,
+          newAssetPriceInfo: { OracleNft: priceOranceNft },
+          newInterestOracleNft: interestOracleNft,
+          newLiquidationRatio: { numerator: 120n, denominator: 100n },
+          newMaintenanceRatio: { numerator: 150n, denominator: 100n },
+          newRedemptionRatio: { numerator: 150n, denominator: 100n },
+          newMinCollateralAmt: 10_000_000n,
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Execute update collateral asset proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        null,
+        null,
+        (
+          await findCollateralAssetNew(
+            context,
+            sysParams,
+            iusdAssetInfo.iassetTokenNameAscii,
+            iusdAssetInfo.collateralAssets[0].collateralAsset,
+          )
+        ).utxo,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute update collateral asset proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, [iusdAssetInfo]] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const [pkh, _] = await addrDetails(context.lucid);
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    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,
+      'NEW_IUSD_ADA_ORACLE',
+      rationalFromInt(1n),
+      { biasTime: 120_000n, expirationPeriod: 1_800_000n, owner: pkh.hash },
+      context.emulator.slot,
+    );
+    await runAndAwaitTxBuilder(context.lucid, priceOracleTx);
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const allIassetOrefs = (
+      await findAllIAssets(
+        context.lucid,
+        sysParams.validatorHashes.iassetHash,
+        fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      )
+    ).map((iasset) => iasset.utxo);
+
+    const [tx, pollId] = await createProposal(
+      {
+        UpdateCollateralAsset: {
+          correspondingIAsset: fromHex(
+            fromText(iusdAssetInfo.iassetTokenNameAscii),
+          ),
+          collateralAsset: iusdAssetInfo.collateralAssets[0].collateralAsset,
+          newAssetExtraDecimals: 0n,
+          newAssetPriceInfo: { OracleNft: priceOranceNft },
+          newInterestOracleNft: interestOracleNft,
+          newLiquidationRatio: { numerator: 120n, denominator: 100n },
+          newMaintenanceRatio: { numerator: 150n, denominator: 100n },
+          newRedemptionRatio: { numerator: 150n, denominator: 100n },
+          newMinCollateralAmt: 10_000_000n,
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      allIassetOrefs,
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 [__, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        await benchmarkAndAwaitTx(
+          'Gov - Execute update collateral asset proposal with treasury withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            (
+              await findGov(
+                context.lucid,
+                sysParams.validatorHashes.govHash,
+                fromSystemParamsAsset(sysParams.govParams.govNFT),
+              )
+            ).utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            null,
+            null,
+            (
+              await findCollateralAssetNew(
+                context,
+                sysParams,
+                iusdAssetInfo.iassetTokenNameAscii,
+                iusdAssetInfo.collateralAssets[0].collateralAsset,
+              )
+            ).utxo,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute create stableswap pool proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const feeManager = fromHex(
+      paymentCredentialOf(context.users.admin.address).hash,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ProposeStableswapPool: {
+          iasset: fromHex(fromText('iUSD')),
+          collateralAsset: EXAMPLE_TOKEN_1,
+          collateralToIassetRatio: rationalFromInt(1n),
+          mintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          redemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          feeManager: feeManager,
+          minMintingAmount: 0n,
+          minRedemptionAmount: 0n,
+          stableswapValHash: fromHex(sysParams.validatorHashes.stableswapHash),
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 iassetReference = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const cdpCreatorUtxo = await findRandomCdpCreator(
+      context.lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute create Stableswap proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetReference.utxo,
+        null,
+        null,
+        cdpCreatorUtxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute create stableswap pool proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const feeManager = fromHex(
+      paymentCredentialOf(context.users.admin.address).hash,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ProposeStableswapPool: {
+          iasset: fromHex(fromText('iUSD')),
+          collateralAsset: EXAMPLE_TOKEN_1,
+          collateralToIassetRatio: rationalFromInt(1n),
+          mintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          redemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          feeManager: feeManager,
+          minMintingAmount: 0n,
+          minRedemptionAmount: 0n,
+          stableswapValHash: fromHex(sysParams.validatorHashes.stableswapHash),
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 iassetReference = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const cdpCreatorUtxo = await findRandomCdpCreator(
+      context.lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute create Stableswap proposal with treasury withdrawal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        treasuryWithdrawalUtxo,
+        null,
+        iassetReference.utxo,
+        null,
+        null,
+        cdpCreatorUtxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute modify stableswap pool proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const feeManager = fromHex(
+      paymentCredentialOf(context.users.admin.address).hash,
+    );
+    const newFeeManager = fromHex(
+      paymentCredentialOf(context.users.user.address).hash,
+    );
+
+    const iassetStableswapPool = fromHex(fromText('iUSD'));
+    const collateralAssetStableswapPool = EXAMPLE_TOKEN_1;
+
+    const [tx1, pollId1] = await createProposal(
+      {
+        ProposeStableswapPool: {
+          iasset: iassetStableswapPool,
+          collateralAsset: collateralAssetStableswapPool,
+          collateralToIassetRatio: rationalFromInt(1n),
+          mintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          redemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          feeManager: feeManager,
+          minMintingAmount: 0n,
+          minRedemptionAmount: 0n,
+          stableswapValHash: fromHex(sysParams.validatorHashes.stableswapHash),
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx1);
+
+    await runCreateAllShards(pollId1, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId1, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId1, sysParams, context);
+
+    await runMergeAllShards(pollId1, sysParams, context);
+
+    await runEndProposal(pollId1, sysParams, context);
+
+    const iassetReference = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const cdpCreatorUtxo = await findRandomCdpCreator(
+      context.lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      executeProposal(
+        (
+          await findExecute(
+            context.lucid,
+            sysParams.validatorHashes.executeHash,
+            fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+            pollId1,
+          )
+        ).utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetReference.utxo,
+        null,
+        null,
+        cdpCreatorUtxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+
+    const [tx2, pollId2] = await createProposal(
+      {
+        ModifyStableswapPool: {
+          iasset: iassetStableswapPool,
+          collateralAsset: collateralAssetStableswapPool,
+          newCollateralToIassetRatio: rationalFromInt(1n),
+          newMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          newRedemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          newMintingEnabled: false,
+          newRedemptionEnabled: true,
+          newFeeManager: newFeeManager,
+          newMinMintingAmount: 1n,
+          newMinRedemptionAmount: 1n,
+          newStableswapValHash: fromHex(
+            fromText(sysParams.validatorHashes.stableswapHash),
+          ),
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx2);
+
+    await runCreateAllShards(pollId2, sysParams, context);
+
+    await runVote(pollId2, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId2, sysParams, context);
+
+    await runMergeAllShards(pollId2, sysParams, context);
+
+    await runEndProposal(pollId2, sysParams, context);
+
+    const stableswapPoolUtxo = await findStableswapPool(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      toHex(iassetStableswapPool),
+      collateralAssetStableswapPool,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute modify Stableswap proposal',
+      await executeProposal(
+        (
+          await findExecute(
+            context.lucid,
+            sysParams.validatorHashes.executeHash,
+            fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+            pollId2,
+          )
+        ).utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        null,
+        null,
+        null,
+        stableswapPoolUtxo.utxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute modify stableswap pool proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const feeManager = fromHex(
+      paymentCredentialOf(context.users.admin.address).hash,
+    );
+    const newFeeManager = fromHex(
+      paymentCredentialOf(context.users.user.address).hash,
+    );
+
+    const iassetStableswapPool = fromHex(fromText('iUSD'));
+    const collateralAssetStableswapPool = EXAMPLE_TOKEN_1;
+
+    const [tx1, pollId1] = await createProposal(
+      {
+        ProposeStableswapPool: {
+          iasset: iassetStableswapPool,
+          collateralAsset: collateralAssetStableswapPool,
+          collateralToIassetRatio: rationalFromInt(1n),
+          mintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          redemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          feeManager: feeManager,
+          minMintingAmount: 0n,
+          minRedemptionAmount: 0n,
+          stableswapValHash: fromHex(sysParams.validatorHashes.stableswapHash),
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx1);
+
+    await runCreateAllShards(pollId1, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    await runVote(pollId1, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId1, sysParams, context);
+
+    await runMergeAllShards(pollId1, sysParams, context);
+
+    await runEndProposal(pollId1, sysParams, context);
+
+    let executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId1,
+    );
+
+    const iassetReference = await findIAsset(
+      context.lucid,
+      sysParams.validatorHashes.iassetHash,
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+      'iUSD',
+    );
+
+    const cdpCreatorUtxo = await findRandomCdpCreator(
+      context.lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    );
+
+    await runAndAwaitTx(
+      context.lucid,
+      executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        iassetReference.utxo,
+        null,
+        null,
+        cdpCreatorUtxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const [tx2, pollId2] = await createProposal(
+      {
+        ModifyStableswapPool: {
+          iasset: iassetStableswapPool,
+          collateralAsset: collateralAssetStableswapPool,
+          newCollateralToIassetRatio: rationalFromInt(1n),
+          newMintingFeeRatio: { numerator: 5n, denominator: 1_000n },
+          newRedemptionFeeRatio: { numerator: 5n, denominator: 1_000n },
+          newMintingEnabled: false,
+          newRedemptionEnabled: true,
+          newFeeManager: newFeeManager,
+          newMinMintingAmount: 1n,
+          newMinRedemptionAmount: 1n,
+          newStableswapValHash: fromHex(
+            fromText(sysParams.validatorHashes.stableswapHash),
+          ),
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      (
+        await findGov(
+          context.lucid,
+          sysParams.validatorHashes.govHash,
+          fromSystemParamsAsset(sysParams.govParams.govNFT),
+        )
+      ).utxo,
+      (
+        await findAllIAssets(
+          context.lucid,
+          sysParams.validatorHashes.iassetHash,
+          fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+        )
+      ).map((iasset) => iasset.utxo),
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx2);
+
+    await runCreateAllShards(pollId2, sysParams, context);
+
+    await runVote(pollId2, 'Yes', sysParams, context);
+
+    await waitForVotingEnd(pollId2, sysParams, context);
+
+    await runMergeAllShards(pollId2, sysParams, context);
+
+    await runEndProposal(pollId2, sysParams, context);
+
+    const stableswapPoolUtxo = await findStableswapPool(
+      context.lucid,
+      sysParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+      toHex(iassetStableswapPool),
+      collateralAssetStableswapPool,
+    );
+
+    executeUtxo = await findExecute(
+      context.lucid,
+      sysParams.validatorHashes.executeHash,
+      fromSystemParamsAsset(sysParams.executeParams.upgradeToken),
+      pollId2,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Execute modify Stableswap proposal with treasury withdrawal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        treasuryWithdrawalUtxo,
+        null,
+        null,
+        null,
+        null,
+        stableswapPoolUtxo.utxo,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute modify protocol params proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ModifyProtocolParams: {
+          newParams: {
+            proposalDeposit: govUtxo.datum.protocolParams.proposalDeposit * 2n,
+            votingPeriod: ONE_DAY * 2n,
+            effectiveDelay: govUtxo.datum.protocolParams.effectiveDelay,
+            expirationPeriod: ONE_DAY * 2n,
+            proposingPeriod: ONE_DAY,
+            /// Total numer of shards used for voting.
+            totalShards: govUtxo.datum.protocolParams.totalShards,
+            /// The minimum number of votes (yes + no votes) for a proposal to be possible to pass.
+            minimumQuorum: govUtxo.datum.protocolParams.minimumQuorum,
+            /// Maximum amount of lovelaces that can be spent at once from the treasury.
+            maxTreasuryLovelaceSpend:
+              govUtxo.datum.protocolParams.maxTreasuryLovelaceSpend,
+            /// Maximum amount of INDY that can be spent at once from the treasury.
+            maxTreasuryIndySpend:
+              govUtxo.datum.protocolParams.maxTreasuryIndySpend,
+            cdpRedemptionRequiredSignature:
+              govUtxo.datum.protocolParams.cdpRedemptionRequiredSignature,
+            electorate: govUtxo.datum.protocolParams.electorate,
+            foundationMultisig: govUtxo.datum.protocolParams.foundationMultisig,
+          },
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Execute modify protocol params proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute modify protocol params proposal with treasury withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        ModifyProtocolParams: {
+          newParams: {
+            proposalDeposit: govUtxo.datum.protocolParams.proposalDeposit * 2n,
+            votingPeriod: ONE_DAY * 2n,
+            effectiveDelay: govUtxo.datum.protocolParams.effectiveDelay,
+            expirationPeriod: ONE_DAY * 2n,
+            proposingPeriod: ONE_DAY,
+            /// Total numer of shards used for voting.
+            totalShards: govUtxo.datum.protocolParams.totalShards,
+            /// The minimum number of votes (yes + no votes) for a proposal to be possible to pass.
+            minimumQuorum: govUtxo.datum.protocolParams.minimumQuorum,
+            /// Maximum amount of lovelaces that can be spent at once from the treasury.
+            maxTreasuryLovelaceSpend:
+              govUtxo.datum.protocolParams.maxTreasuryLovelaceSpend,
+            /// Maximum amount of INDY that can be spent at once from the treasury.
+            maxTreasuryIndySpend:
+              govUtxo.datum.protocolParams.maxTreasuryIndySpend,
+            cdpRedemptionRequiredSignature:
+              govUtxo.datum.protocolParams.cdpRedemptionRequiredSignature,
+            electorate: govUtxo.datum.protocolParams.electorate,
+            foundationMultisig: govUtxo.datum.protocolParams.foundationMultisig,
+          },
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 [__, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        benchmarkAndAwaitTx(
+          'Execute modify protocol params proposal with treasury withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            (
+              await findGov(
+                context.lucid,
+                sysParams.validatorHashes.govHash,
+                fromSystemParamsAsset(sysParams.govParams.govNFT),
+              )
+            ).utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            null,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+
+  test<MyContext>('Execute upgrade protocol proposal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        UpgradeProtocol: {
+          content: {
+            upgradeId: govUtxo.datum.currentVersion + 1n,
+            upgradePaths: [
+              [
+                fromHex(sysParams.validatorHashes.cdpHash),
+                // NOTICE: this is just a placeholder, in real scenario it needs upgrade minting policy hash
+                {
+                  upgradeSymbol: fromHex(
+                    sysParams.validatorHashes.cdpCreatorHash,
+                  ),
+                },
+              ],
+            ],
+          },
+        },
+      },
+      null,
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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,
+    );
+
+    await benchmarkAndAwaitTx(
+      'Gov - Execute upgrade protocol proposal',
+      await executeProposal(
+        executeUtxo.utxo,
+        (
+          await findGov(
+            context.lucid,
+            sysParams.validatorHashes.govHash,
+            fromSystemParamsAsset(sysParams.govParams.govNFT),
+          )
+        ).utxo,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        sysParams,
+        context.lucid,
+        context.emulator.slot,
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<MyContext>('Execute upgrade protocol proposal with withdrawal', async (context: MyContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+    const [sysParams, _] = await init(
+      context.lucid,
+      [iusdInitialAssetCfg()],
+      context.emulator.slot,
+    );
+
+    const withdrawalIndyAmt = 1_000n;
+    const treasuryWithdrawalUtxo = await createIndyUtxoAtTreasury(
+      withdrawalIndyAmt,
+      sysParams,
+      context,
+    );
+
+    const govUtxo = await findGov(
+      context.lucid,
+      sysParams.validatorHashes.govHash,
+      fromSystemParamsAsset(sysParams.govParams.govNFT),
+    );
+
+    const [tx, pollId] = await createProposal(
+      {
+        UpgradeProtocol: {
+          content: {
+            upgradeId: govUtxo.datum.currentVersion + 1n,
+            upgradePaths: [
+              [
+                fromHex(sysParams.validatorHashes.cdpHash),
+                // NOTICE: this is just a placeholder, in real scenario it needs upgrade minting policy hash
+                {
+                  upgradeSymbol: fromHex(
+                    sysParams.validatorHashes.cdpCreatorHash,
+                  ),
+                },
+              ],
+            ],
+          },
+        },
+      },
+      {
+        destination: addressFromBech32(context.users.withdrawalAccount.address),
+        value: [
+          {
+            currencySymbol: fromHex(
+              sysParams.govParams.indyAsset[0].unCurrencySymbol,
+            ),
+            tokenName: fromHex(
+              fromText(sysParams.govParams.indyAsset[1].unTokenName),
+            ),
+            amount: withdrawalIndyAmt,
+          },
+        ],
+      },
+      sysParams,
+      context.lucid,
+      context.emulator.slot,
+      govUtxo.utxo,
+      [],
+    );
+
+    await runAndAwaitTxBuilder(context.lucid, tx);
+
+    await runCreateAllShards(pollId, sysParams, context);
+
+    await runAndAwaitTx(
+      context.lucid,
+      openStakingPosition(100_000_000_000n, sysParams, context.lucid),
+    );
+
+    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 [__, newVal] = await getValueChangeAtAddressAfterAction(
+      context.lucid,
+      context.users.withdrawalAccount.address,
+      async () =>
+        benchmarkAndAwaitTx(
+          'Gov - Execute upgrade protocol proposal with withdrawal',
+          await executeProposal(
+            executeUtxo.utxo,
+            (
+              await findGov(
+                context.lucid,
+                sysParams.validatorHashes.govHash,
+                fromSystemParamsAsset(sysParams.govParams.govNFT),
+              )
+            ).utxo,
+            treasuryWithdrawalUtxo,
+            null,
+            null,
+            null,
+            null,
+            null,
+            sysParams,
+            context.lucid,
+            context.emulator.slot,
+          ),
+          context.lucid,
+          context.emulator,
+        ),
+    );
+
+    expect(
+      assetClassValueOf(
+        newVal,
+        fromSystemParamsAsset(sysParams.govParams.indyAsset),
+      ) === withdrawalIndyAmt,
+      'Unexpected withdrawn indy amt',
+    ).toBeTruthy();
+  });
+});