@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/gov/transactions.ts

@@ -1,3 +1,4 @@
+// import { OutRef } from '@lucid-evolution/lucid';
 import {
   addAssets,
   Assets,
@@ -7,91 +8,96 @@ import {
   OutRef,
   paymentCredentialOf,
   slotToUnixTime,
-  toText,
+  toHex,
   TxBuilder,
   UTxO,
 } from '@lucid-evolution/lucid';
-import {
-  parseGovDatumOrThrow,
-  serialiseGovDatum,
-  serialiseGovRedeemer,
-  TreasuryWithdrawal,
-} from '../gov/types';
+
 import { matchSingle } from '../../utils/utils';
 import {
   createScriptAddress,
   getInlineDatumOrThrow,
-  resolveUtxo,
-  UtxoOrOutRef,
 } from '../../utils/lucid-utils';
-import {
-  parsePollManagerOrThrow,
-  parsePollShardOrThrow,
-  PollShardContent,
-  PollStatus,
-  serialisePollDatum,
-} from '../poll/types-poll';
+
 import {
   assetClassValueOf,
   isAssetsZero,
+  isSameAssetClass,
   lovelacesAmt,
   mkAssetsOf,
   mkLovelacesOf,
   negateAssets,
-} from '../../utils/value-helpers';
+} from '@3rd-eye-labs/cardano-offchain-common';
 import { Data } from '@lucid-evolution/lucid';
 import { pipe } from 'fp-ts/lib/function';
 import { array as A, option as O, function as F } from 'fp-ts';
 import { match, P } from 'ts-pattern';
 import {
-  fromSysParamsScriptCredential,
+  fromSysParamsCredential,
   fromSystemParamsAsset,
   fromSystemParamsScriptRef,
   SystemParams,
 } from '../../types/system-params';
-import { serialisePollManagerRedeemer } from '../poll/types-poll-manager';
 import { ONE_SECOND } from '../../utils/time-helpers';
-import { addressFromBech32, addressToBech32 } from '../../types/generic';
-import { serialiseStakingRedeemer } from '../staking/types';
-import {
-  serialisePollShardRedeemer,
-  VoteOption,
-} from '../poll/types-poll-shard';
 import {
   parseStakingPositionOrThrow,
   serialiseStakingDatum,
+  serialiseStakingRedeemer,
   StakingPosLockedAmt,
 } from '../staking/types-new';
 import { updateStakingLockedAmount } from '../staking/helpers';
 import { pollPassQuorum } from '../poll/helpers';
+import {
+  collateralAssetCreationDatumHelper,
+  createValueFromWithdrawal,
+  findRelativeCollateralAssetForInsertion,
+  findRelativeIAssetForInsertion,
+  iassetCreationDatumHelper,
+  proposalDeposit,
+} from './helpers';
+import { initSpState } from '../stability-pool/helpers';
+import { serialiseVersionRecordDatum } from '../version-registry/types-new';
+import {
+  parseGovDatumOrThrow,
+  ProposalContent,
+  serialiseGovDatum,
+  serialiseGovRedeemer,
+  TreasuryWithdrawal,
+} from './types-new';
+import { serialiseStabilityPoolDatum } from '../stability-pool/types-new';
+import {
+  parsePollManagerOrThrow,
+  parsePollShardOrThrow,
+  PollShardContent,
+  PollStatus,
+  serialisePollDatum,
+  serialisePollManagerRedeemer,
+  serialisePollShardRedeemer,
+  VoteOption,
+} from '../poll/types-poll-new';
 import {
   parseExecuteDatumOrThrow,
   serialiseExecuteDatum,
-} from '../execute/types';
+} from '../execute/types-new';
+import {
+  addressFromBech32,
+  addressToBech32,
+} from '@3rd-eye-labs/cardano-offchain-common';
 import {
   serialiseTreasuryRedeemer,
   serialiseWithdrawalOutputDatum,
-} from '../treasury/types';
-import { bigintMin } from '../../utils/bigint-utils';
-import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
+} from '../treasury/types-new';
 import {
+  parseCollateralAssetDatumOrThrow,
   parseIAssetDatumOrThrow,
-  serialiseCdpRedeemer,
   serialiseIAssetDatum,
-} from '../cdp/types';
-import {
-  createValueFromWithdrawal,
-  findRelativeIAssetForInsertion,
-  iassetCreationDatumHelper,
-  proposalDeposit,
-} from './helpers';
+  serialiseIAssetRedeemer,
+} from '../iasset/types';
+import { serialiseCDPCreatorRedeemer } from '../cdp-creator/types-new';
 import {
-  initEpochToScaleToSumMap,
-  initSpSnapshot,
-} from '../stability-pool/helpers';
-import { serialiseVersionRecordDatum } from '../version-registry/types-new';
-import { parseUpgradePaths, ProposalContent } from './types-new';
-import { serialiseStabilityPoolDatum } from '../stability-pool/types-new';
+  serialiseCdpRedeemer,
+  serialiseStableswapPoolDatum,
+} from '../cdp/types-new';
 
 /**
  * Returns the new PollId.
@@ -102,11 +108,11 @@ export async function createProposal(
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
-  gov: UtxoOrOutRef,
+  govOref: OutRef,
   /**
    * This has to be passed only in case of createAsset proposal
    */
-  allIAssetOrefs: OutRef[],
+  allIAssetOrefs: OutRef[] | undefined,
 ): Promise<[TxBuilder, bigint]> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -131,7 +137,10 @@ export async function createProposal(
     (_) =>
       new Error('Expected a single poll auth token policy ref Script UTXO'),
   );
-  const govUtxo = await resolveUtxo(gov, lucid, 'Expected a single Gov UTXO');
+  const govUtxo = matchSingle(
+    await lucid.utxosByOutRef([govOref]),
+    (_) => new Error('Expected a single Gov UTXO'),
+  );
 
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
 
@@ -152,9 +161,13 @@ export async function createProposal(
 
   // Add iAsset ref input when Propose asset proposal
   await match(proposalContent)
-    .with({ ProposeAsset: { asset: P.select() } }, async (newAsset) => {
+    .with({ ProposeIAsset: { asset: P.select() } }, async (newAsset) => {
+      if (allIAssetOrefs === undefined) {
+        throw new Error('Missing iAsset orefs');
+      }
+
       const relativeIAsset = await findRelativeIAssetForInsertion(
-        toText(newAsset),
+        newAsset,
         allIAssetOrefs,
         lucid,
       );
@@ -188,7 +201,7 @@ export async function createProposal(
           CreatePoll: {
             content: proposalContent,
             currentTime: currentTime,
-            proposalOwner: pkh.hash,
+            proposalOwner: fromHex(pkh.hash),
             treasuryWithdrawal: treasuryWithdrawal,
           },
         }),
@@ -211,21 +224,19 @@ export async function createProposal(
           kind: 'inline',
           value: serialisePollDatum({
             PollManager: {
-              content: {
-                pollId: newPollId,
-                pollOwner: pkh.hash,
-                content: proposalContent,
-                treasuryWithdrawal: treasuryWithdrawal,
-                status: { yesVotes: 0n, noVotes: 0n },
-                votingEndTime: votingEndTime,
-                createdShardsCount: 0n,
-                talliedShardsCount: 0n,
-                totalShardsCount: govDatum.protocolParams.totalShards,
-                proposingEndTime: proposingEndTime,
-                expirationTime: expirationTime,
-                protocolVersion: govDatum.currentVersion,
-                minimumQuorum: govDatum.protocolParams.minimumQuorum,
-              },
+              pollId: newPollId,
+              pollOwner: fromHex(pkh.hash),
+              content: proposalContent,
+              treasuryWithdrawal: treasuryWithdrawal,
+              status: { yesVotes: 0n, noVotes: 0n },
+              votingEndTime: votingEndTime,
+              createdShardsCount: 0n,
+              talliedShardsCount: 0n,
+              totalShardsCount: govDatum.protocolParams.totalShards,
+              proposingEndTime: proposingEndTime,
+              expirationTime: expirationTime,
+              protocolVersion: govDatum.currentVersion,
+              minimumQuorum: govDatum.protocolParams.minimumQuorum,
             },
           }),
         },
@@ -255,7 +266,7 @@ export async function createShardsChunks(
    * This gets automatically capped to total shards count.
    */
   chunkSize: bigint,
-  pollManager: UtxoOrOutRef,
+  pollManagerOref: OutRef,
   sysParams: SystemParams,
   currentSlot: number,
   lucid: LucidEvolution,
@@ -265,19 +276,16 @@ export async function createShardsChunks(
 
   const ownAddr = await lucid.wallet().address();
 
-  const pollManagerUtxo = await resolveUtxo(
-    pollManager,
-    lucid,
-    'Expected a single Poll manager UTXO',
+  const pollManagerUtxo = matchSingle(
+    await lucid.utxosByOutRef([pollManagerOref]),
+    (_) => new Error('Expected a single Poll manager UTXO'),
   );
 
-  const pollManagerDatum = parsePollManagerOrThrow(
+  const pollManager = parsePollManagerOrThrow(
     getInlineDatumOrThrow(pollManagerUtxo),
   );
 
-  if (
-    pollManagerDatum.createdShardsCount >= pollManagerDatum.totalShardsCount
-  ) {
+  if (pollManager.createdShardsCount >= pollManager.totalShardsCount) {
     throw new Error('All shards already created.');
   }
 
@@ -303,9 +311,7 @@ export async function createShardsChunks(
   const shardsCount = BigInt(
     Math.min(
       Number(chunkSize),
-      Number(
-        pollManagerDatum.totalShardsCount - pollManagerDatum.createdShardsCount,
-      ),
+      Number(pollManager.totalShardsCount - pollManager.createdShardsCount),
     ),
   );
 
@@ -330,11 +336,8 @@ export async function createShardsChunks(
         kind: 'inline',
         value: serialisePollDatum({
           PollManager: {
-            content: {
-              ...pollManagerDatum,
-              createdShardsCount:
-                pollManagerDatum.createdShardsCount + shardsCount,
-            },
+            ...pollManager,
+            createdShardsCount: pollManager.createdShardsCount + shardsCount,
           },
         }),
       },
@@ -349,12 +352,10 @@ export async function createShardsChunks(
         kind: 'inline',
         value: serialisePollDatum({
           PollShard: {
-            content: {
-              pollId: pollManagerDatum.pollId,
-              status: { yesVotes: 0n, noVotes: 0n },
-              votingEndTime: pollManagerDatum.votingEndTime,
-              managerAddress: addressFromBech32(pollManagerUtxo.address),
-            },
+            pollId: pollManager.pollId,
+            status: { yesVotes: 0n, noVotes: 0n },
+            votingEndTime: pollManager.votingEndTime,
+            managerAddress: addressFromBech32(pollManagerUtxo.address),
           },
         }),
       },
@@ -387,24 +388,21 @@ function voteHelper(
     }))
     .exhaustive();
 
-  const newLockedAmt: [
-    bigint,
-    { readonly voteAmt: bigint; readonly votingEnd: bigint },
-  ][] = [
-    ...updateStakingLockedAmount(stakingPosLockedAmt, currentTime).entries(),
+  const newLockedAmt: StakingPosLockedAmt = [
+    ...updateStakingLockedAmount(stakingPosLockedAmt, currentTime),
     [
-      pollShard.pollId,
+      BigInt(pollShard.pollId),
       { voteAmt: indyStakedAmt, votingEnd: pollShard.votingEndTime },
     ],
   ];
 
-  return [new Map(newLockedAmt), newPollStatus];
+  return [newLockedAmt, newPollStatus];
 }
 
 export async function vote(
   voteOption: VoteOption,
-  pollShard: UtxoOrOutRef,
-  stakingPosition: UtxoOrOutRef,
+  pollShardOref: OutRef,
+  stakingPositionOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -429,19 +427,17 @@ export async function vote(
     (_) => new Error('Expected a single staking ref Script UTXO'),
   );
 
-  const pollShardUtxo = await resolveUtxo(
-    pollShard,
-    lucid,
-    'Expected a single Poll shard UTXO',
+  const pollShardUtxo = matchSingle(
+    await lucid.utxosByOutRef([pollShardOref]),
+    (_) => new Error('Expected a single Poll shard UTXO'),
   );
   const pollShardDatum = parsePollShardOrThrow(
     getInlineDatumOrThrow(pollShardUtxo),
   );
 
-  const stakingPosUtxo = await resolveUtxo(
-    stakingPosition,
-    lucid,
-    'Expected a single staking position UTXO',
+  const stakingPosUtxo = matchSingle(
+    await lucid.utxosByOutRef([stakingPositionOref]),
+    (_) => new Error('Expected a single staking position UTXO'),
   );
   const stakingPosDatum = parseStakingPositionOrThrow(
     getInlineDatumOrThrow(stakingPosUtxo),
@@ -452,11 +448,12 @@ export async function vote(
     fromSystemParamsAsset(sysParams.govParams.indyAsset),
   );
 
-  const validityFrom =
-    Number(currentTime) -
-    Math.min(120 * ONE_SECOND, Number(sysParams.govParams.gBiasTime));
+  const validityFrom = Number(currentTime) - ONE_SECOND;
 
-  if (stakingPosDatum.lockedAmount.has(pollShardDatum.pollId)) {
+  if (
+    stakingPosDatum.lockedAmount.find((x) => x[0] === pollShardDatum.pollId) !==
+    undefined
+  ) {
     throw new Error('Already voted for that proposal.');
   }
 
@@ -471,19 +468,12 @@ export async function vote(
   return lucid
     .newTx()
     .validFrom(validityFrom)
-    .validTo(
-      Math.min(
-        Number(pollShardDatum.votingEndTime) - ONE_SECOND,
-        Number(currentTime) +
-          Number(sysParams.govParams.gBiasTime) -
-          ONE_SECOND,
-      ),
-    )
+    .validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND)
     .readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo])
     .collectFrom([stakingPosUtxo], serialiseStakingRedeemer('Lock'))
     .collectFrom(
       [pollShardUtxo],
-      serialisePollShardRedeemer({ Vote: { content: voteOption } }),
+      serialisePollShardRedeemer({ Vote: voteOption }),
     )
     .pay.ToContract(
       pollShardUtxo.address,
@@ -491,10 +481,8 @@ export async function vote(
         kind: 'inline',
         value: serialisePollDatum({
           PollShard: {
-            content: {
-              ...pollShardDatum,
-              status: newVoteStatus,
-            },
+            ...pollShardDatum,
+            status: newVoteStatus,
           },
         }),
       },
@@ -515,7 +503,7 @@ export async function vote(
 }
 
 export async function mergeShards(
-  pollManager: UtxoOrOutRef,
+  pollManagerOref: OutRef,
   shardsOutRefs: OutRef[],
   sysParams: SystemParams,
   lucid: LucidEvolution,
@@ -553,10 +541,9 @@ export async function mergeShards(
       new Error('Expected a single poll auth token policy ref Script UTXO'),
   );
 
-  const pollManagerUtxo = await resolveUtxo(
-    pollManager,
-    lucid,
-    'Expected a single Poll manager UTXO',
+  const pollManagerUtxo = matchSingle(
+    await lucid.utxosByOutRef([pollManagerOref]),
+    (_) => new Error('Expected a single Poll manager UTXO'),
   );
 
   const pollManagerDatum = parsePollManagerOrThrow(
@@ -608,7 +595,7 @@ export async function mergeShards(
           currentTime: currentTime,
           pollManagerRef: {
             outputIndex: BigInt(pollManagerUtxo.outputIndex),
-            txHash: { hash: pollManagerUtxo.txHash },
+            txHash: fromHex(pollManagerUtxo.txHash),
           },
         },
       }),
@@ -619,13 +606,11 @@ export async function mergeShards(
         kind: 'inline',
         value: serialisePollDatum({
           PollManager: {
-            content: {
-              ...pollManagerDatum,
-              talliedShardsCount:
-                pollManagerDatum.talliedShardsCount +
-                BigInt(shardsOutRefs.length),
-              status: aggregatedStatus,
-            },
+            ...pollManagerDatum,
+            talliedShardsCount:
+              pollManagerDatum.talliedShardsCount +
+              BigInt(shardsOutRefs.length),
+            status: aggregatedStatus,
           },
         }),
       },
@@ -635,8 +620,8 @@ export async function mergeShards(
 }
 
 export async function endProposal(
-  pollManager: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
+  pollManagerOref: OutRef,
+  govOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -681,16 +666,18 @@ export async function endProposal(
       new Error('Expected a single upgrade auth token policy ref Script UTXO'),
   );
 
-  const pollManagerUtxo = await resolveUtxo(
-    pollManager,
-    lucid,
-    'Expected a single Poll manager UTXO',
+  const pollManagerUtxo = matchSingle(
+    await lucid.utxosByOutRef([pollManagerOref]),
+    (_) => new Error('Expected a single Poll manager UTXO'),
   );
-  const pollManagerDatum = parsePollManagerOrThrow(
+  const pollManager = parsePollManagerOrThrow(
     getInlineDatumOrThrow(pollManagerUtxo),
   );
 
-  const govUtxo = await resolveUtxo(gov, lucid, 'Expected a single Gov UTXO');
+  const govUtxo = matchSingle(
+    await lucid.utxosByOutRef([govOref]),
+    (_) => new Error('Expected a single Gov UTXO'),
+  );
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
 
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
@@ -698,15 +685,13 @@ export async function endProposal(
     sysParams.pollManagerParams.indyAsset,
   );
 
-  const proposalExpired = currentTime > pollManagerDatum.expirationTime;
+  const proposalExpired = currentTime > pollManager.expirationTime;
   const proposalPassed =
     !proposalExpired &&
     pollPassQuorum(
-      sysParams.pollManagerParams.initialIndyDistribution,
-      pollManagerDatum.status,
-      currentTime,
-      pollManagerDatum.minimumQuorum,
-      govDatum.treasuryIndyWithdrawnAmt,
+      pollManager.status,
+      govDatum.protocolParams.electorate,
+      pollManager.minimumQuorum,
     );
 
   const upgradeTokenVal = mkAssetsOf(
@@ -755,12 +740,12 @@ export async function endProposal(
         {
           kind: 'inline',
           value: serialiseExecuteDatum({
-            id: pollManagerDatum.pollId,
-            content: pollManagerDatum.content,
+            id: pollManager.pollId,
+            content: pollManager.content,
             passedTime: currentTime,
-            votingEndTime: pollManagerDatum.votingEndTime,
-            protocolVersion: pollManagerDatum.protocolVersion,
-            treasuryWithdrawal: pollManagerDatum.treasuryWithdrawal,
+            votingEndTime: pollManager.votingEndTime,
+            protocolVersion: pollManager.protocolVersion,
+            treasuryWithdrawal: pollManager.treasuryWithdrawal,
           }),
         },
         upgradeTokenVal,
@@ -781,11 +766,21 @@ export async function endProposal(
 }
 
 export async function executeProposal(
-  execute: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasuryWithdrawal: UtxoOrOutRef | null,
+  executeOref: OutRef,
+  govOref: OutRef,
+  treasuryWithdrawalOref: OutRef | null,
   allIAssetOrefs: OutRef[] | null,
-  modifyIAsset: UtxoOrOutRef | null,
+  /**
+   * This for either Propose IAsset, Modify IAsset or Add Collateral asset proposals.
+   */
+  iAssetOref: OutRef | null,
+  /**
+   * This is when adding new collateral asset. It should be all collateral assets of the given iAsset
+   * where it's adding the new collateral asset.
+   */
+  allCollateralAssetsOrefsOfIAsset: OutRef[] | null,
+  collateralAssetOref: OutRef | null,
+  stableswapPoolOrCdpCreatorOref: OutRef | null,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -795,7 +790,10 @@ export async function executeProposal(
 
   const ownAddr = await lucid.wallet().address();
 
-  const govUtxo = await resolveUtxo(gov, lucid, 'Expected a single gov UTXO');
+  const govUtxo = matchSingle(
+    await lucid.utxosByOutRef([govOref]),
+    (_) => new Error('Expected a single gov UTXO'),
+  );
 
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
 
@@ -824,27 +822,15 @@ export async function executeProposal(
       new Error('Expected a single upgrade auth token policy ref Script UTXO'),
   );
 
-  const executeUtxo = await resolveUtxo(
-    execute,
-    lucid,
-    'Expected a single execute UTXO',
+  const executeUtxo = matchSingle(
+    await lucid.utxosByOutRef([executeOref]),
+    (_) => new Error('Expected a single execute UTXO'),
   );
 
   const executeDatum = parseExecuteDatumOrThrow(
     getInlineDatumOrThrow(executeUtxo),
   );
 
-  const indyWithdrawalAmt = assetClassValueOf(
-    executeDatum.treasuryWithdrawal
-      ? createValueFromWithdrawal(executeDatum.treasuryWithdrawal)
-      : {},
-    fromSystemParamsAsset(sysParams.govParams.indyAsset),
-  );
-  const newTreasuryWithdrawnIndyAmtCapped = bigintMin(
-    4_822_081n * OCD_DECIMAL_UNIT,
-    govDatum.treasuryIndyWithdrawnAmt + indyWithdrawalAmt,
-  );
-
   const tx = lucid.newTx();
 
   // Handle treasury withdrawal
@@ -852,13 +838,13 @@ export async function executeProposal(
     O.fromNullable(executeDatum.treasuryWithdrawal),
     O.match(
       () => {
-        if (treasuryWithdrawal) {
+        if (treasuryWithdrawalOref) {
           throw new Error('Cannot provide withdrawal oref when no withdrawal.');
         }
         return Promise.resolve();
       },
       async (withdrawal) => {
-        if (!treasuryWithdrawal) {
+        if (!treasuryWithdrawalOref) {
           throw new Error('Have to provide withdrawal oref when withdrawal.');
         }
 
@@ -871,10 +857,9 @@ export async function executeProposal(
           (_) => new Error('Expected a single Treasury Ref Script UTXO'),
         );
 
-        const treasuryWithdrawalUtxo = await resolveUtxo(
-          treasuryWithdrawal,
-          lucid,
-          'Expected a single withdrawal UTXO',
+        const treasuryWithdrawalUtxo = matchSingle(
+          await lucid.utxosByOutRef([treasuryWithdrawalOref]),
+          (_) => new Error('Expected a single withdrawal UTXO'),
         );
 
         const withdrawalVal = createValueFromWithdrawal(withdrawal);
@@ -889,7 +874,7 @@ export async function executeProposal(
               network,
               sysParams.validatorHashes.treasuryHash,
               sysParams.treasuryParams.treasuryUtxosStakeCredential
-                ? fromSysParamsScriptCredential(
+                ? fromSysParamsCredential(
                     sysParams.treasuryParams.treasuryUtxosStakeCredential,
                   )
                 : undefined,
@@ -909,9 +894,9 @@ export async function executeProposal(
             {
               kind: 'inline',
               value: serialiseWithdrawalOutputDatum([
-                fromText('IndigoTreasuryWithdrawal'),
+                fromHex(fromText('IndigoTreasuryWithdrawal')),
                 {
-                  txHash: { hash: executeUtxo.txHash },
+                  txHash: fromHex(executeUtxo.txHash),
                   outputIndex: BigInt(executeUtxo.outputIndex),
                 },
               ]),
@@ -923,7 +908,7 @@ export async function executeProposal(
   );
 
   await match(executeDatum.content)
-    .with({ ProposeAsset: P.select() }, async (proposeContent) => {
+    .with({ ProposeIAsset: P.select() }, async (proposeContent) => {
       const iassetTokenPolicyRefScriptUtxo = matchSingle(
         await lucid.utxosByOutRef([
           fromSystemParamsScriptRef(
@@ -946,11 +931,13 @@ export async function executeProposal(
           new Error('Expected a single SP auth token policy ref Script UTXO'),
       );
 
-      const cdpRefScriptUtxo = matchSingle(
+      const iassetRefScriptUtxo = matchSingle(
         await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.iassetValidatorRef,
+          ),
         ]),
-        (_) => new Error('Expected a single CDP Ref Script UTXO'),
+        (_) => new Error('Expected a single IAsset Ref Script UTXO'),
       );
 
       if (!allIAssetOrefs) {
@@ -958,7 +945,7 @@ export async function executeProposal(
       }
 
       const iassetToReference = await findRelativeIAssetForInsertion(
-        toText(proposeContent.asset),
+        proposeContent.asset,
         allIAssetOrefs,
         lucid,
       );
@@ -982,7 +969,7 @@ export async function executeProposal(
 
       tx.readFrom([
         govRefScriptUtxo,
-        cdpRefScriptUtxo,
+        iassetRefScriptUtxo,
         iassetTokenPolicyRefScriptUtxo,
         stabilityPoolTokenPolicyRefScriptUtxo,
       ])
@@ -995,15 +982,17 @@ export async function executeProposal(
             kind: 'inline',
             value: serialiseGovDatum({
               ...govDatum,
-              treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
               iassetsCount: govDatum.iassetsCount + 1n,
             }),
           },
           govUtxo.assets,
         )
         .pay.ToContract(
-          createScriptAddress(network, sysParams.validatorHashes.cdpHash),
-          { kind: 'inline', value: serialiseIAssetDatum(newIAsset) },
+          createScriptAddress(network, sysParams.validatorHashes.iassetHash),
+          {
+            kind: 'inline',
+            value: serialiseIAssetDatum({ IAssetContent: newIAsset }),
+          },
           iassetAuthVal,
         )
         .pay.ToContract(
@@ -1016,9 +1005,9 @@ export async function executeProposal(
             value: serialiseStabilityPoolDatum(
               {
                 StabilityPool: {
-                  asset: fromHex(proposeContent.asset),
-                  poolSnapshot: initSpSnapshot,
-                  epochToScaleToSum: initEpochToScaleToSumMap(),
+                  iasset: proposeContent.asset,
+                  state: initSpState,
+                  assetStates: [],
                 },
               },
               true,
@@ -1041,14 +1030,22 @@ export async function executeProposal(
                   throw new Error('Expected some referenced iasset.');
                 },
                 (newRefIAsset) => {
-                  tx.collectFrom(
-                    [i.utxo],
-                    serialiseCdpRedeemer('UpdateOrInsertAsset'),
-                  ).pay.ToContract(
+                  tx.collectFrom([i.utxo], {
+                    kind: 'selected',
+                    makeRedeemer: (inputIndices) =>
+                      serialiseIAssetRedeemer({
+                        UpdateOrInsertAsset: {
+                          executeInputIdx: inputIndices[0],
+                        },
+                      }),
+                    inputs: [executeUtxo],
+                  }).pay.ToContract(
                     i.utxo.address,
                     {
                       kind: 'inline',
-                      value: serialiseIAssetDatum(newRefIAsset),
+                      value: serialiseIAssetDatum({
+                        IAssetContent: newRefIAsset,
+                      }),
                     },
                     i.utxo.assets,
                   );
@@ -1058,96 +1055,430 @@ export async function executeProposal(
         ),
       );
     })
-    .with({ ModifyAsset: P.select() }, async (modifyContent) => {
-      const cdpRefScriptUtxo = matchSingle(
+    .with({ ModifyIAsset: P.select() }, async (modifyContent) => {
+      const iassetRefScriptUtxo = matchSingle(
         await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.iassetValidatorRef,
+          ),
         ]),
         (_) => new Error('Expected a single CDP Ref Script UTXO'),
       );
 
-      if (!modifyIAsset) {
+      if (!iAssetOref) {
         throw new Error('Have to provide iasset oref when modify asset.');
       }
 
-      const iassetUtxo = await resolveUtxo(
-        modifyIAsset,
-        lucid,
-        'Expected a single iasset UTXO',
+      const iassetUtxo = matchSingle(
+        await lucid.utxosByOutRef([iAssetOref]),
+        (_) => new Error('Expected a single iasset UTXO'),
       );
 
       const iassetDatum = parseIAssetDatumOrThrow(
         getInlineDatumOrThrow(iassetUtxo),
       );
 
-      tx.readFrom([cdpRefScriptUtxo])
-        .collectFrom([iassetUtxo], serialiseCdpRedeemer('UpdateOrInsertAsset'))
+      tx.readFrom([iassetRefScriptUtxo])
+        .collectFrom([iassetUtxo], {
+          kind: 'selected',
+          makeRedeemer: (inputIndices) =>
+            serialiseIAssetRedeemer({
+              UpdateOrInsertAsset: {
+                executeInputIdx: inputIndices[0],
+              },
+            }),
+          inputs: [executeUtxo],
+        })
         .pay.ToContract(
-          createScriptAddress(network, sysParams.validatorHashes.cdpHash),
+          createScriptAddress(network, sysParams.validatorHashes.iassetHash),
           {
             kind: 'inline',
             value: serialiseIAssetDatum({
-              assetName: iassetDatum.assetName,
-              price: modifyContent.newAssetPriceInfo,
-              interestOracleNft: modifyContent.newInterestOracleNft,
-              redemptionRatio: modifyContent.newRedemptionRatioPercentage,
-              maintenanceRatio: modifyContent.newMaintenanceRatioPercentage,
-              liquidationRatio: modifyContent.newLiquidationRatioPercentage,
-              debtMintingFeePercentage:
-                modifyContent.newDebtMintingFeePercentage,
-              liquidationProcessingFeePercentage:
-                modifyContent.newLiquidationProcessingFeePercentage,
-              stabilityPoolWithdrawalFeePercentage:
-                modifyContent.newStabilityPoolWithdrawalFeePercentage,
-              redemptionReimbursementPercentage:
-                modifyContent.newRedemptionReimbursementPercentage,
-              redemptionProcessingFeePercentage:
-                modifyContent.newRedemptionProcessingFeePercentage,
-              interestCollectorPortionPercentage:
-                modifyContent.newInterestCollectorPortionPercentage,
-              firstIAsset: iassetDatum.firstIAsset,
-              nextIAsset: iassetDatum.nextIAsset,
+              IAssetContent: {
+                assetName: iassetDatum.assetName,
+                collateralAssetsCount: iassetDatum.collateralAssetsCount,
+                debtMintingFeeRatio: modifyContent.newDebtMintingFeeRatio,
+                liquidationProcessingFeeRatio:
+                  modifyContent.newLiquidationProcessingFeeRatio,
+                stabilityPoolWithdrawalFeeRatio:
+                  modifyContent.newStabilityPoolWithdrawalFeeRatio,
+                redemptionReimbursementRatio:
+                  modifyContent.newRedemptionReimbursementRatio,
+                redemptionProcessingFeeRatio:
+                  modifyContent.newRedemptionProcessingFeeRatio,
+                firstIAsset: iassetDatum.firstIAsset,
+                nextIAsset: iassetDatum.nextIAsset,
+              },
             }),
           },
           iassetUtxo.assets,
+        )
+        .readFrom([govUtxo])
+        .setMinFee(900_000n);
+    })
+    .with({ AddCollateralAsset: P.select() }, async (addCollateralContent) => {
+      const collateralAssetTokenPolicyRefScriptUtxo = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.authTokenPolicies
+              .collateralAssetTokenRef,
+          ),
+        ]),
+        (_) =>
+          new Error(
+            'Expected a single collateral asset auth token policy ref Script UTXO',
+          ),
+      );
+
+      const iassetRefScriptUtxo = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.iassetValidatorRef,
+          ),
+        ]),
+        (_) => new Error('Expected a single iasset Ref Script UTXO'),
+      );
+
+      if (!iAssetOref) {
+        throw new Error(
+          'Have to provide iasset oref when add collateral asset.',
         );
+      }
 
-      if (indyWithdrawalAmt > 0) {
-        tx.readFrom([govRefScriptUtxo])
-          .collectFrom([govUtxo], serialiseGovRedeemer('UpgradeGov'))
-          .pay.ToContract(
-            govUtxo.address,
-            {
-              kind: 'inline',
-              value: serialiseGovDatum({
-                ...govDatum,
-                treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
-              }),
-            },
-            govUtxo.assets,
-          );
-      } else {
-        tx.readFrom([govUtxo]);
+      const iassetUtxo = matchSingle(
+        await lucid.utxosByOutRef([iAssetOref]),
+        (_) => new Error('Expected a single iasset UTXO'),
+      );
+      const iassetDatum = parseIAssetDatumOrThrow(
+        getInlineDatumOrThrow(iassetUtxo),
+      );
+
+      if (!allCollateralAssetsOrefsOfIAsset) {
+        throw new Error(
+          'Have to provide all collateral asset orefs when propose asset.',
+        );
       }
+
+      const collateralAssetToReference =
+        await findRelativeCollateralAssetForInsertion(
+          addCollateralContent.collateralAsset,
+          allCollateralAssetsOrefsOfIAsset,
+          lucid,
+        );
+
+      const { newCollateralAsset, newReferencedCollateralAsset } =
+        collateralAssetCreationDatumHelper(
+          addCollateralContent,
+          F.pipe(
+            collateralAssetToReference,
+            O.map((i) => i.datum),
+          ),
+        );
+
+      const collateralAssetAuthVal = mkAssetsOf(
+        fromSystemParamsAsset(sysParams.executeParams.collateralAssetToken),
+        1n,
+      );
+
+      tx.readFrom([
+        iassetRefScriptUtxo,
+        collateralAssetTokenPolicyRefScriptUtxo,
+      ]);
+      tx.readFrom([govUtxo])
+        .mintAssets(collateralAssetAuthVal, Data.void())
+        .collectFrom([iassetUtxo], {
+          kind: 'selected',
+          makeRedeemer: (inputIndices) =>
+            serialiseIAssetRedeemer({
+              UpdateOrInsertAsset: {
+                executeInputIdx: inputIndices[0],
+              },
+            }),
+          inputs: [executeUtxo],
+        })
+        .pay.ToContract(
+          createScriptAddress(network, sysParams.validatorHashes.iassetHash),
+          {
+            kind: 'inline',
+            value: serialiseIAssetDatum({
+              IAssetContent: {
+                ...iassetDatum,
+                collateralAssetsCount: iassetDatum.collateralAssetsCount + 1n,
+              },
+            }),
+          },
+          iassetUtxo.assets,
+        )
+        .pay.ToContract(
+          createScriptAddress(network, sysParams.validatorHashes.iassetHash),
+          {
+            kind: 'inline',
+            value: serialiseIAssetDatum({
+              CollateralAssetContent: newCollateralAsset,
+            }),
+          },
+          collateralAssetAuthVal,
+        );
+
+      F.pipe(
+        collateralAssetToReference,
+        O.match(
+          () => {
+            // no action
+          },
+          (i) => {
+            F.pipe(
+              newReferencedCollateralAsset,
+              O.match(
+                () => {
+                  throw new Error('Expected some referenced collateral asset');
+                },
+                (newRefCollateralAsset) => {
+                  tx.collectFrom([i.utxo], {
+                    kind: 'selected',
+                    makeRedeemer: (inputIndices) =>
+                      serialiseIAssetRedeemer({
+                        UpdateOrInsertAsset: {
+                          executeInputIdx: inputIndices[0],
+                        },
+                      }),
+                    inputs: [executeUtxo],
+                  }).pay.ToContract(
+                    createScriptAddress(
+                      network,
+                      sysParams.validatorHashes.iassetHash,
+                    ),
+                    {
+                      kind: 'inline',
+                      value: serialiseIAssetDatum({
+                        CollateralAssetContent: newRefCollateralAsset,
+                      }),
+                    },
+                    i.utxo.assets,
+                  );
+                },
+              ),
+            );
+          },
+        ),
+      );
     })
-    .with({ TextProposal: P.any }, () => {
-      if (indyWithdrawalAmt > 0) {
-        tx.readFrom([govRefScriptUtxo])
-          .collectFrom([govUtxo], serialiseGovRedeemer('UpgradeGov'))
+    .with(
+      { UpdateCollateralAsset: P.select() },
+      async (updateCollateralContent) => {
+        const iassetRefScriptUtxo = matchSingle(
+          await lucid.utxosByOutRef([
+            fromSystemParamsScriptRef(
+              sysParams.scriptReferences.iassetValidatorRef,
+            ),
+          ]),
+          (_) => new Error('Expected a single iasset Ref Script UTXO'),
+        );
+
+        if (!collateralAssetOref) {
+          throw new Error(
+            'Have to provide collateral asset oref when add collateral asset.',
+          );
+        }
+
+        const collateralAssetUtxo = matchSingle(
+          await lucid.utxosByOutRef([collateralAssetOref]),
+          (_) => new Error('Expected a single collateral asset UTXO'),
+        );
+        const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+          getInlineDatumOrThrow(collateralAssetUtxo),
+        );
+
+        if (
+          !isSameAssetClass(
+            collateralAssetDatum.collateralAsset,
+            updateCollateralContent.collateralAsset,
+          ) ||
+          toHex(collateralAssetDatum.iasset) !==
+            toHex(updateCollateralContent.correspondingIAsset)
+        ) {
+          throw new Error('Wrong collateral asset.');
+        }
+
+        tx.readFrom([iassetRefScriptUtxo])
+          .collectFrom([collateralAssetUtxo], {
+            kind: 'selected',
+            makeRedeemer: (inputIndices) =>
+              serialiseIAssetRedeemer({
+                UpdateOrInsertAsset: {
+                  executeInputIdx: inputIndices[0],
+                },
+              }),
+            inputs: [executeUtxo],
+          })
           .pay.ToContract(
-            govUtxo.address,
+            createScriptAddress(network, sysParams.validatorHashes.iassetHash),
             {
               kind: 'inline',
-              value: serialiseGovDatum({
-                ...govDatum,
-                treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
+              value: serialiseIAssetDatum({
+                CollateralAssetContent: {
+                  ...collateralAssetDatum,
+                  priceInfo: updateCollateralContent.newAssetPriceInfo,
+                  interestOracleNft:
+                    updateCollateralContent.newInterestOracleNft,
+                  redemptionRatio: updateCollateralContent.newRedemptionRatio,
+                  maintenanceRatio: updateCollateralContent.newMaintenanceRatio,
+                  liquidationRatio: updateCollateralContent.newLiquidationRatio,
+                  minCollateralAmt: updateCollateralContent.newMinCollateralAmt,
+                },
               }),
             },
-            govUtxo.assets,
-          );
-      } else {
-        tx.readFrom([govUtxo]);
+            collateralAssetUtxo.assets,
+          )
+          .readFrom([govUtxo])
+          .setMinFee(900_000n);
+      },
+    )
+    .with({ TextProposal: P.any }, () => {
+      tx.readFrom([govUtxo]);
+    })
+    .with({ ProposeStableswapPool: P.select() }, async (proposeContent) => {
+      const cdpCreatorRefScriptUtxo = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.cdpCreatorValidatorRef,
+          ),
+        ]),
+        (_) => new Error('Expected a single CDP Creator Ref Script UTXO'),
+      );
+
+      const cdpTokenPolicyRefScriptUtxo = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(
+            sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef,
+          ),
+        ]),
+        (_) =>
+          new Error('Expected a single CDP auth token policy ref Script UTXO'),
+      );
+
+      if (!iAssetOref) {
+        throw new Error(
+          'Have to provide iasset oref when proposing stableswap pool.',
+        );
+      }
+
+      const iassetUtxo = matchSingle(
+        await lucid.utxosByOutRef([iAssetOref]),
+        (_) => new Error('Expected a single iasset UTXO'),
+      );
+
+      const cdpAuthVal = mkAssetsOf(
+        fromSystemParamsAsset(sysParams.executeParams.cdpToken),
+        1n,
+      );
+
+      if (!stableswapPoolOrCdpCreatorOref) {
+        throw new Error(
+          'Have to provide cdp creator oref when propose stableswap pool.',
+        );
       }
+
+      const cdpCreatorUtxo = matchSingle(
+        await lucid.utxosByOutRef([stableswapPoolOrCdpCreatorOref]),
+        (_) => new Error('Expected a single iasset UTXO'),
+      );
+
+      tx.readFrom([
+        cdpCreatorRefScriptUtxo,
+        cdpTokenPolicyRefScriptUtxo,
+        govUtxo,
+        iassetUtxo,
+      ])
+        .mintAssets(cdpAuthVal, Data.void())
+        .collectFrom(
+          [cdpCreatorUtxo],
+          serialiseCDPCreatorRedeemer('CreateStableswapPool'),
+        )
+        .pay.ToContract(
+          createScriptAddress(
+            network,
+            sysParams.validatorHashes.cdpCreatorHash,
+          ),
+          { kind: 'inline', value: Data.void() },
+          cdpCreatorUtxo.assets,
+        )
+        .pay.ToContract(
+          createScriptAddress(network, sysParams.validatorHashes.cdpHash),
+          {
+            kind: 'inline',
+            value: serialiseStableswapPoolDatum({
+              iasset: proposeContent.iasset,
+              collateralAsset: proposeContent.collateralAsset,
+              collateralToIassetRatio: proposeContent.collateralToIassetRatio,
+              mintingFeeRatio: proposeContent.mintingFeeRatio,
+              redemptionFeeRatio: proposeContent.redemptionFeeRatio,
+              mintingEnabled: true,
+              redemptionEnabled: true,
+              feeManager: proposeContent.feeManager,
+              minMintOrderAmount: proposeContent.minMintingAmount,
+              minRedemptionOrderAmount: proposeContent.minRedemptionAmount,
+              stableswapValHash: proposeContent.stableswapValHash,
+            }),
+          },
+          cdpAuthVal,
+        );
+    })
+    .with({ ModifyStableswapPool: P.select() }, async (modifyContent) => {
+      const cdpRefScriptUtxo = matchSingle(
+        await lucid.utxosByOutRef([
+          fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
+        ]),
+        (_) => new Error('Expected a single CDP Ref Script UTXO'),
+      );
+
+      if (!stableswapPoolOrCdpCreatorOref) {
+        throw new Error(
+          'Have to provide stableswap pool oref when propose stableswap pool.',
+        );
+      }
+
+      const stableswapPoolUtxo = matchSingle(
+        await lucid.utxosByOutRef([stableswapPoolOrCdpCreatorOref]),
+        (_) => new Error('Expected a single stableswap pool UTXO'),
+      );
+
+      tx.readFrom([govRefScriptUtxo, cdpRefScriptUtxo, govUtxo])
+        .collectFrom([stableswapPoolUtxo], {
+          kind: 'selected',
+          makeRedeemer: (inputIndices) =>
+            serialiseCdpRedeemer({
+              Stableswap: {
+                forwardingInputIndex: inputIndices[0],
+              },
+            }),
+          inputs: [executeUtxo],
+        })
+        .pay.ToContract(
+          createScriptAddress(network, sysParams.validatorHashes.cdpHash),
+          {
+            kind: 'inline',
+            value: serialiseStableswapPoolDatum({
+              iasset: modifyContent.iasset,
+              collateralAsset: modifyContent.collateralAsset,
+              collateralToIassetRatio: modifyContent.newCollateralToIassetRatio,
+              mintingFeeRatio: modifyContent.newMintingFeeRatio,
+              redemptionFeeRatio: modifyContent.newRedemptionFeeRatio,
+              mintingEnabled: modifyContent.newMintingEnabled,
+              redemptionEnabled: modifyContent.newRedemptionEnabled,
+              feeManager: modifyContent.newFeeManager,
+              minMintOrderAmount: modifyContent.newMinMintingAmount,
+              minRedemptionOrderAmount: modifyContent.newMinRedemptionAmount,
+              stableswapValHash: modifyContent.newStableswapValHash,
+            }),
+          },
+          stableswapPoolUtxo.assets,
+        )
+        // This has to be added as otherwise there is the following error:
+        // TxBuilderError: { Complete: RedeemerBuilder: Coin selection had to be updated
+        // after building redeemers, possibly leading to incorrect indices. Try setting
+        // a minimum fee of 1416197 lovelaces. }
+        .setMinFee(1416197n);
     })
     .with(
       { ModifyProtocolParams: { newParams: P.select() } },
@@ -1161,7 +1492,6 @@ export async function executeProposal(
               value: serialiseGovDatum({
                 ...govDatum,
                 protocolParams: newProtocolParams,
-                treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
               }),
             },
             govUtxo.assets,
@@ -1169,12 +1499,11 @@ export async function executeProposal(
       },
     )
     .with({ UpgradeProtocol: P.select() }, async (d) => {
-      const upgradeDetails = parseUpgradePaths(d.content);
-
       const versionRecordTokenPolicyRefScriptUtxo = matchSingle(
         await lucid.utxosByOutRef([
           fromSystemParamsScriptRef(
-            sysParams.scriptReferences.versionRecordTokenPolicyRef,
+            sysParams.scriptReferences.authTokenPolicies
+              .versionRecordTokenPolicyRef,
           ),
         ]),
         (_) =>
@@ -1198,12 +1527,11 @@ export async function executeProposal(
           {
             kind: 'inline',
             value: serialiseVersionRecordDatum({
-              upgradeId: upgradeDetails.upgradeId,
-              upgradePaths: new Map(
-                upgradeDetails.upgradePaths
-                  .entries()
-                  .map(([h1, h2]) => [h1, h2.upgradeSymbol]),
-              ),
+              upgradeId: d.content.upgradeId,
+              upgradePaths: d.content.upgradePaths.map(([h1, h2]) => [
+                h1,
+                h2.upgradeSymbol,
+              ]),
             }),
           },
           versionRecordNftVal,
@@ -1216,13 +1544,12 @@ export async function executeProposal(
             value: serialiseGovDatum({
               ...govDatum,
               currentVersion: govDatum.currentVersion + 1n,
-              treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
             }),
           },
           govUtxo.assets,
         );
     })
-    .exhaustive();
+    .otherwise(() => {});
 
   tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo])
     .validFrom(Number(currentTime) - ONE_SECOND)
@@ -1232,7 +1559,8 @@ export async function executeProposal(
       mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
       Data.void(),
     )
-    .addSigner(ownAddr);
+    .addSigner(ownAddr)
+    .setMinFee(922932n);
 
   return tx;
 }