@indigo-labs/indigo-sdk 0.1.21 → 0.1.23

package/src/contracts/gov/transactions.ts

@@ -1,1224 +0,0 @@
-// import { OutRef } from '@lucid-evolution/lucid';
-import {
-  addAssets,
-  Assets,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  OutRef,
-  paymentCredentialOf,
-  slotToUnixTime,
-  toText,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  parseGovDatumOrThrow,
-  serialiseGovDatum,
-  serialiseGovRedeemer,
-  TreasuryWithdrawal,
-} from '../gov/types';
-import { matchSingle } from '../../utils/utils';
-import {
-  createScriptAddress,
-  getInlineDatumOrThrow,
-} from '../../utils/lucid-utils';
-import {
-  parsePollManagerOrThrow,
-  parsePollShardOrThrow,
-  PollShardContent,
-  PollStatus,
-  serialisePollDatum,
-} from '../poll/types-poll';
-import {
-  assetClassValueOf,
-  isAssetsZero,
-  lovelacesAmt,
-  mkAssetsOf,
-  mkLovelacesOf,
-  negateAssets,
-} from '../../utils/value-helpers';
-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,
-  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,
-  StakingPosLockedAmt,
-} from '../staking/types-new';
-import { updateStakingLockedAmount } from '../staking/helpers';
-import { pollPassQuorum } from '../poll/helpers';
-import {
-  parseExecuteDatumOrThrow,
-  serialiseExecuteDatum,
-} from '../execute/types';
-import {
-  serialiseTreasuryRedeemer,
-  serialiseWithdrawalOutputDatum,
-} from '../treasury/types';
-import { bigintMin } from '../../utils/bigint-utils';
-import { OCD_DECIMAL_UNIT } from '../../types/on-chain-decimal';
-import {
-  parseIAssetDatumOrThrow,
-  serialiseCdpRedeemer,
-  serialiseIAssetDatum,
-} from '../cdp/types';
-import {
-  createValueFromWithdrawal,
-  findRelativeIAssetForInsertion,
-  iassetCreationDatumHelper,
-  proposalDeposit,
-} from './helpers';
-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';
-
-/**
- * Returns the new PollId.
- */
-export async function createProposal(
-  proposalContent: ProposalContent,
-  treasuryWithdrawal: TreasuryWithdrawal | null,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  currentSlot: number,
-  govOref: OutRef,
-  /**
-   * This has to be passed only in case of createAsset proposal
-   */
-  allIAssetOrefs: OutRef[],
-): Promise<[TxBuilder, bigint]> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-  const pkh = paymentCredentialOf(ownAddr);
-
-  const govRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.governanceValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single Gov Ref Script UTXO'),
-  );
-  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single poll auth token policy ref Script UTXO'),
-  );
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error('Expected a single Gov UTXO'),
-  );
-
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-
-  const votingEndTime = currentTime + govDatum.protocolParams.votingPeriod;
-  const expirationTime =
-    votingEndTime + govDatum.protocolParams.expirationPeriod;
-  const proposingEndTime =
-    currentTime + govDatum.protocolParams.proposingPeriod;
-
-  const pollNftValue = mkAssetsOf(
-    fromSystemParamsAsset(sysParams.govParams.pollToken),
-    1n,
-  );
-
-  const newPollId = govDatum.currentProposal + 1n;
-
-  const tx = lucid.newTx();
-
-  // Add iAsset ref input when Propose asset proposal
-  await match(proposalContent)
-    .with({ ProposeAsset: { asset: P.select() } }, async (newAsset) => {
-      const relativeIAsset = await findRelativeIAssetForInsertion(
-        toText(newAsset),
-        allIAssetOrefs,
-        lucid,
-      );
-
-      pipe(
-        relativeIAsset,
-        O.match(
-          () => {
-            if (govDatum.iassetsCount !== 0n) {
-              throw new Error(
-                'Has to find relative iAsset when there are iAssets.',
-              );
-            }
-          },
-          (relative) => {
-            tx.readFrom([relative.utxo]);
-          },
-        ),
-      );
-    })
-    .otherwise(() => {});
-
-  return [
-    tx
-      .mintAssets(pollNftValue, Data.void())
-      // Ref scripts
-      .readFrom([govRefScriptUtxo, pollAuthTokenPolicyRefScriptUtxo])
-      .collectFrom(
-        [govUtxo],
-        serialiseGovRedeemer({
-          CreatePoll: {
-            content: proposalContent,
-            currentTime: currentTime,
-            proposalOwner: pkh.hash,
-            treasuryWithdrawal: treasuryWithdrawal,
-          },
-        }),
-      )
-      .pay.ToContract(
-        govUtxo.address,
-        {
-          kind: 'inline',
-          value: serialiseGovDatum({
-            ...govDatum,
-            currentProposal: govDatum.currentProposal + 1n,
-            activeProposals: govDatum.activeProposals + 1n,
-          }),
-        },
-        govUtxo.assets,
-      )
-      .pay.ToContract(
-        createScriptAddress(network, sysParams.validatorHashes.pollManagerHash),
-        {
-          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,
-              },
-            },
-          }),
-        },
-        addAssets(
-          pollNftValue,
-          mkAssetsOf(
-            fromSystemParamsAsset(sysParams.govParams.indyAsset),
-            proposalDeposit(
-              govDatum.protocolParams.proposalDeposit,
-              govDatum.activeProposals,
-            ),
-          ),
-        ),
-      )
-      .validFrom(Number(currentTime) - ONE_SECOND)
-      .validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND)
-      .addSigner(ownAddr),
-    newPollId,
-  ];
-}
-
-/**
- * Builds transaction creating shards of count chunk size.
- */
-export async function createShardsChunks(
-  /**
-   * This gets automatically capped to total shards count.
-   */
-  chunkSize: bigint,
-  pollManagerOref: OutRef,
-  sysParams: SystemParams,
-  currentSlot: number,
-  lucid: LucidEvolution,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error('Expected a single Poll manager UTXO'),
-  );
-
-  const pollManager = parsePollManagerOrThrow(
-    getInlineDatumOrThrow(pollManagerUtxo),
-  );
-
-  if (pollManager.createdShardsCount >= pollManager.totalShardsCount) {
-    throw new Error('All shards already created.');
-  }
-
-  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single poll auth token policy ref Script UTXO'),
-  );
-  const pollManagerRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.pollManagerValidatorRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single poll auth token policy ref Script UTXO'),
-  );
-
-  const shardsCount = BigInt(
-    Math.min(
-      Number(chunkSize),
-      Number(pollManager.totalShardsCount - pollManager.createdShardsCount),
-    ),
-  );
-
-  const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
-
-  const tx = lucid
-    .newTx()
-    .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(
-      Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
-    )
-    .mintAssets(mkAssetsOf(pollNft, shardsCount), Data.void())
-    // Ref scripts
-    .readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo])
-    .collectFrom(
-      [pollManagerUtxo],
-      serialisePollManagerRedeemer({ CreateShards: { currentTime } }),
-    )
-    .pay.ToContract(
-      pollManagerUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePollDatum({
-          PollManager: {
-            content: {
-              ...pollManager,
-              createdShardsCount: pollManager.createdShardsCount + shardsCount,
-            },
-          },
-        }),
-      },
-      pollManagerUtxo.assets,
-    )
-    .addSigner(ownAddr);
-
-  for (let idx = 0; idx < shardsCount; idx++) {
-    tx.pay.ToContract(
-      createScriptAddress(network, sysParams.validatorHashes.pollShardHash),
-      {
-        kind: 'inline',
-        value: serialisePollDatum({
-          PollShard: {
-            content: {
-              pollId: pollManager.pollId,
-              status: { yesVotes: 0n, noVotes: 0n },
-              votingEndTime: pollManager.votingEndTime,
-              managerAddress: addressFromBech32(pollManagerUtxo.address),
-            },
-          },
-        }),
-      },
-      mkAssetsOf(pollNft, 1n),
-    );
-  }
-
-  return tx;
-}
-
-/**
- * Updates both locked amount and poll status based on the vote.
- */
-function voteHelper(
-  stakingPosLockedAmt: StakingPosLockedAmt,
-  pollShard: PollShardContent,
-  voteOption: VoteOption,
-  currentTime: bigint,
-  indyStakedAmt: bigint,
-): [StakingPosLockedAmt, PollStatus] {
-  const newPollStatus = match(voteOption)
-    .returnType<PollStatus>()
-    .with('Yes', () => ({
-      ...pollShard.status,
-      yesVotes: pollShard.status.yesVotes + indyStakedAmt,
-    }))
-    .with('No', () => ({
-      ...pollShard.status,
-      noVotes: pollShard.status.noVotes + indyStakedAmt,
-    }))
-    .exhaustive();
-
-  const newLockedAmt: [
-    bigint,
-    { readonly voteAmt: bigint; readonly votingEnd: bigint },
-  ][] = [
-    ...updateStakingLockedAmount(stakingPosLockedAmt, currentTime).entries(),
-    [
-      pollShard.pollId,
-      { voteAmt: indyStakedAmt, votingEnd: pollShard.votingEndTime },
-    ],
-  ];
-
-  return [new Map(newLockedAmt), newPollStatus];
-}
-
-export async function vote(
-  voteOption: VoteOption,
-  pollShardOref: OutRef,
-  stakingPositionOref: OutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  currentSlot: number,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-
-  const pollShardRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.pollShardValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single poll shard ref Script UTXO'),
-  );
-  const stakingRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.stakingValidatorRef),
-    ]),
-    (_) => new Error('Expected a single staking ref Script UTXO'),
-  );
-
-  const pollShardUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollShardOref]),
-    (_) => new Error('Expected a single Poll shard UTXO'),
-  );
-  const pollShardDatum = parsePollShardOrThrow(
-    getInlineDatumOrThrow(pollShardUtxo),
-  );
-
-  const stakingPosUtxo = matchSingle(
-    await lucid.utxosByOutRef([stakingPositionOref]),
-    (_) => new Error('Expected a single staking position UTXO'),
-  );
-  const stakingPosDatum = parseStakingPositionOrThrow(
-    getInlineDatumOrThrow(stakingPosUtxo),
-  );
-
-  const indyStakedAmt = assetClassValueOf(
-    stakingPosUtxo.assets,
-    fromSystemParamsAsset(sysParams.govParams.indyAsset),
-  );
-
-  const validityFrom = Number(currentTime) - ONE_SECOND;
-
-  if (stakingPosDatum.lockedAmount.has(pollShardDatum.pollId)) {
-    throw new Error('Already voted for that proposal.');
-  }
-
-  const [newLockedAmt, newVoteStatus] = voteHelper(
-    stakingPosDatum.lockedAmount,
-    pollShardDatum,
-    voteOption,
-    BigInt(validityFrom),
-    indyStakedAmt,
-  );
-
-  return lucid
-    .newTx()
-    .validFrom(validityFrom)
-    .validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND)
-    .readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo])
-    .collectFrom([stakingPosUtxo], serialiseStakingRedeemer('Lock'))
-    .collectFrom(
-      [pollShardUtxo],
-      serialisePollShardRedeemer({ Vote: { content: voteOption } }),
-    )
-    .pay.ToContract(
-      pollShardUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePollDatum({
-          PollShard: {
-            content: {
-              ...pollShardDatum,
-              status: newVoteStatus,
-            },
-          },
-        }),
-      },
-      pollShardUtxo.assets,
-    )
-    .pay.ToContract(
-      stakingPosUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStakingDatum({
-          ...stakingPosDatum,
-          lockedAmount: newLockedAmt,
-        }),
-      },
-      stakingPosUtxo.assets,
-    )
-    .addSigner(ownAddr);
-}
-
-export async function mergeShards(
-  pollManagerOref: OutRef,
-  shardsOutRefs: OutRef[],
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  currentSlot: number,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-
-  const pollShardRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.pollShardValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single poll shard ref Script UTXO'),
-  );
-  const pollManagerRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.pollManagerValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single poll shard ref Script UTXO'),
-  );
-
-  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single poll auth token policy ref Script UTXO'),
-  );
-
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error('Expected a single Poll manager UTXO'),
-  );
-
-  const pollManagerDatum = parsePollManagerOrThrow(
-    getInlineDatumOrThrow(pollManagerUtxo),
-  );
-
-  const shardUtxos = await lucid.utxosByOutRef(shardsOutRefs);
-
-  const aggregatedStatus: PollStatus = F.pipe(
-    shardUtxos,
-    A.map((utxo) => parsePollShardOrThrow(getInlineDatumOrThrow(utxo))),
-    A.reduce<PollShardContent, PollStatus>(
-      pollManagerDatum.status,
-      (acc, shard) => ({
-        yesVotes: acc.yesVotes + shard.status.yesVotes,
-        noVotes: acc.noVotes + shard.status.noVotes,
-      }),
-    ),
-  );
-
-  const shardsAggregatedAda = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
-    addAssets(acc, mkLovelacesOf(lovelacesAmt(utxo.assets))),
-  )(shardUtxos);
-
-  const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
-
-  return lucid
-    .newTx()
-    .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(
-      Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
-    )
-    .readFrom([
-      pollShardRefScriptUtxo,
-      pollManagerRefScriptUtxo,
-      pollAuthTokenPolicyRefScriptUtxo,
-    ])
-    .mintAssets(mkAssetsOf(pollNft, -BigInt(shardsOutRefs.length)), Data.void())
-    .collectFrom(
-      [pollManagerUtxo],
-      serialisePollManagerRedeemer({
-        MergeShardsManager: { currentTime: currentTime },
-      }),
-    )
-    .collectFrom(
-      shardUtxos,
-      serialisePollShardRedeemer({
-        MergeShards: {
-          currentTime: currentTime,
-          pollManagerRef: {
-            outputIndex: BigInt(pollManagerUtxo.outputIndex),
-            txHash: { hash: pollManagerUtxo.txHash },
-          },
-        },
-      }),
-    )
-    .pay.ToContract(
-      pollManagerUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePollDatum({
-          PollManager: {
-            content: {
-              ...pollManagerDatum,
-              talliedShardsCount:
-                pollManagerDatum.talliedShardsCount +
-                BigInt(shardsOutRefs.length),
-              status: aggregatedStatus,
-            },
-          },
-        }),
-      },
-      addAssets(pollManagerUtxo.assets, shardsAggregatedAda),
-    )
-    .addSigner(ownAddr);
-}
-
-export async function endProposal(
-  pollManagerOref: OutRef,
-  govOref: OutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  currentSlot: number,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-
-  const pollManagerRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.pollManagerValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single poll shard ref Script UTXO'),
-  );
-  const govRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.governanceValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single Gov Ref Script UTXO'),
-  );
-  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single poll auth token policy ref Script UTXO'),
-  );
-  const upgradeTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.upgradeTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single upgrade auth token policy ref Script UTXO'),
-  );
-
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error('Expected a single Poll manager UTXO'),
-  );
-  const pollManager = parsePollManagerOrThrow(
-    getInlineDatumOrThrow(pollManagerUtxo),
-  );
-
-  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);
-  const indyAsset = fromSystemParamsAsset(
-    sysParams.pollManagerParams.indyAsset,
-  );
-
-  const proposalExpired = currentTime > pollManager.expirationTime;
-  const proposalPassed =
-    !proposalExpired &&
-    pollPassQuorum(
-      sysParams.pollManagerParams.initialIndyDistribution,
-      pollManager.status,
-      currentTime,
-      pollManager.minimumQuorum,
-      govDatum.treasuryIndyWithdrawnAmt,
-    );
-
-  const upgradeTokenVal = mkAssetsOf(
-    fromSystemParamsAsset(sysParams.govParams.upgradeToken),
-    1n,
-  );
-
-  const tx = lucid
-    .newTx()
-    .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(
-      Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
-    )
-    .readFrom([
-      pollManagerRefScriptUtxo,
-      govRefScriptUtxo,
-      pollAuthTokenPolicyRefScriptUtxo,
-      upgradeTokenPolicyRefScriptUtxo,
-    ])
-    .collectFrom(
-      [pollManagerUtxo],
-      serialisePollManagerRedeemer({ EndPoll: { currentTime: currentTime } }),
-    )
-    .collectFrom(
-      [govUtxo],
-      serialiseGovRedeemer({ WitnessEndPoll: { currentTime: currentTime } }),
-    )
-    .mintAssets(mkAssetsOf(pollNft, -1n), Data.void())
-    .pay.ToContract(
-      govUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseGovDatum({
-          ...govDatum,
-          activeProposals: govDatum.activeProposals - 1n,
-        }),
-      },
-      govUtxo.assets,
-    )
-    .addSigner(ownAddr);
-
-  if (proposalPassed) {
-    tx.pay
-      .ToContract(
-        createScriptAddress(network, sysParams.validatorHashes.executeHash),
-        {
-          kind: 'inline',
-          value: serialiseExecuteDatum({
-            id: pollManager.pollId,
-            content: pollManager.content,
-            passedTime: currentTime,
-            votingEndTime: pollManager.votingEndTime,
-            protocolVersion: pollManager.protocolVersion,
-            treasuryWithdrawal: pollManager.treasuryWithdrawal,
-          }),
-        },
-        upgradeTokenVal,
-      )
-      .mintAssets(upgradeTokenVal, Data.void());
-  } else {
-    tx.pay.ToContract(
-      createScriptAddress(network, sysParams.validatorHashes.treasuryHash),
-      { kind: 'inline', value: Data.void() },
-      mkAssetsOf(
-        indyAsset,
-        assetClassValueOf(pollManagerUtxo.assets, indyAsset),
-      ),
-    );
-  }
-
-  return tx;
-}
-
-export async function executeProposal(
-  executeOref: OutRef,
-  govOref: OutRef,
-  treasuryWithdrawalOref: OutRef | null,
-  allIAssetOrefs: OutRef[] | null,
-  modifyIAssetOref: OutRef | null,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  currentSlot: number,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
-
-  const ownAddr = await lucid.wallet().address();
-
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error('Expected a single gov UTXO'),
-  );
-
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-
-  const govRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.governanceValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single Gov Ref Script UTXO'),
-  );
-  const executeRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.executeValidatorRef),
-    ]),
-    (_) => new Error('Expected a single execute Ref Script UTXO'),
-  );
-
-  const upgradeTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.upgradeTokenRef,
-      ),
-    ]),
-    (_) =>
-      new Error('Expected a single upgrade auth token policy ref Script 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
-  await pipe(
-    O.fromNullable(executeDatum.treasuryWithdrawal),
-    O.match(
-      () => {
-        if (treasuryWithdrawalOref) {
-          throw new Error('Cannot provide withdrawal oref when no withdrawal.');
-        }
-        return Promise.resolve();
-      },
-      async (withdrawal) => {
-        if (!treasuryWithdrawalOref) {
-          throw new Error('Have to provide withdrawal oref when withdrawal.');
-        }
-
-        const treasuryRefScriptUtxo = matchSingle(
-          await lucid.utxosByOutRef([
-            fromSystemParamsScriptRef(
-              sysParams.scriptReferences.treasuryValidatorRef,
-            ),
-          ]),
-          (_) => new Error('Expected a single Treasury Ref Script UTXO'),
-        );
-
-        const treasuryWithdrawalUtxo = matchSingle(
-          await lucid.utxosByOutRef([treasuryWithdrawalOref]),
-          (_) => new Error('Expected a single withdrawal UTXO'),
-        );
-
-        const withdrawalVal = createValueFromWithdrawal(withdrawal);
-        const withdrawalChangeVal = addAssets(
-          treasuryWithdrawalUtxo.assets,
-          negateAssets(withdrawalVal),
-        );
-
-        if (!isAssetsZero(withdrawalChangeVal)) {
-          tx.pay.ToContract(
-            createScriptAddress(
-              network,
-              sysParams.validatorHashes.treasuryHash,
-              sysParams.treasuryParams.treasuryUtxosStakeCredential
-                ? fromSysParamsScriptCredential(
-                    sysParams.treasuryParams.treasuryUtxosStakeCredential,
-                  )
-                : undefined,
-            ),
-            { kind: 'inline', value: Data.void() },
-            withdrawalChangeVal,
-          );
-        }
-
-        tx.readFrom([treasuryRefScriptUtxo])
-          .collectFrom(
-            [treasuryWithdrawalUtxo],
-            serialiseTreasuryRedeemer('Withdraw'),
-          )
-          .pay.ToAddressWithData(
-            addressToBech32(withdrawal.destination, lucid.config().network!),
-            {
-              kind: 'inline',
-              value: serialiseWithdrawalOutputDatum([
-                fromText('IndigoTreasuryWithdrawal'),
-                {
-                  txHash: { hash: executeUtxo.txHash },
-                  outputIndex: BigInt(executeUtxo.outputIndex),
-                },
-              ]),
-            },
-            withdrawalVal,
-          );
-      },
-    ),
-  );
-
-  await match(executeDatum.content)
-    .with({ ProposeAsset: P.select() }, async (proposeContent) => {
-      const iassetTokenPolicyRefScriptUtxo = matchSingle(
-        await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(
-            sysParams.scriptReferences.authTokenPolicies.iAssetAuthTokenRef,
-          ),
-        ]),
-        (_) =>
-          new Error(
-            'Expected a single iasset auth token policy ref Script UTXO',
-          ),
-      );
-      const stabilityPoolTokenPolicyRefScriptUtxo = matchSingle(
-        await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(
-            sysParams.scriptReferences.authTokenPolicies
-              .stabilityPoolAuthTokenRef,
-          ),
-        ]),
-        (_) =>
-          new Error('Expected a single SP auth token policy ref Script UTXO'),
-      );
-
-      const cdpRefScriptUtxo = matchSingle(
-        await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-        ]),
-        (_) => new Error('Expected a single CDP Ref Script UTXO'),
-      );
-
-      if (!allIAssetOrefs) {
-        throw new Error('Have to provide all iasset orefs when propose asset.');
-      }
-
-      const iassetToReference = await findRelativeIAssetForInsertion(
-        toText(proposeContent.asset),
-        allIAssetOrefs,
-        lucid,
-      );
-
-      const { newIAsset, newReferencedIAsset } = iassetCreationDatumHelper(
-        proposeContent,
-        F.pipe(
-          iassetToReference,
-          O.map((i) => i.datum),
-        ),
-      );
-
-      const iassetAuthVal = mkAssetsOf(
-        fromSystemParamsAsset(sysParams.executeParams.iAssetToken),
-        1n,
-      );
-      const spAuthVal = mkAssetsOf(
-        fromSystemParamsAsset(sysParams.executeParams.stabilityPoolToken),
-        1n,
-      );
-
-      tx.readFrom([
-        govRefScriptUtxo,
-        cdpRefScriptUtxo,
-        iassetTokenPolicyRefScriptUtxo,
-        stabilityPoolTokenPolicyRefScriptUtxo,
-      ])
-        .mintAssets(spAuthVal, Data.void())
-        .mintAssets(iassetAuthVal, Data.void())
-        .collectFrom([govUtxo], serialiseGovRedeemer('UpgradeGov'))
-        .pay.ToContract(
-          govUtxo.address,
-          {
-            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) },
-          iassetAuthVal,
-        )
-        .pay.ToContract(
-          createScriptAddress(
-            network,
-            sysParams.validatorHashes.stabilityPoolHash,
-          ),
-          {
-            kind: 'inline',
-            value: serialiseStabilityPoolDatum(
-              {
-                StabilityPool: {
-                  asset: fromHex(proposeContent.asset),
-                  poolSnapshot: initSpSnapshot,
-                  epochToScaleToSum: initEpochToScaleToSumMap(),
-                },
-              },
-              true,
-            ),
-          },
-          spAuthVal,
-        );
-
-      F.pipe(
-        iassetToReference,
-        O.match(
-          () => {
-            // no action
-          },
-          (i) =>
-            F.pipe(
-              newReferencedIAsset,
-              O.match(
-                () => {
-                  throw new Error('Expected some referenced iasset.');
-                },
-                (newRefIAsset) => {
-                  tx.collectFrom(
-                    [i.utxo],
-                    serialiseCdpRedeemer('UpdateOrInsertAsset'),
-                  ).pay.ToContract(
-                    i.utxo.address,
-                    {
-                      kind: 'inline',
-                      value: serialiseIAssetDatum(newRefIAsset),
-                    },
-                    i.utxo.assets,
-                  );
-                },
-              ),
-            ),
-        ),
-      );
-    })
-    .with({ ModifyAsset: P.select() }, async (modifyContent) => {
-      const cdpRefScriptUtxo = matchSingle(
-        await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-        ]),
-        (_) => new Error('Expected a single CDP Ref Script UTXO'),
-      );
-
-      if (!modifyIAssetOref) {
-        throw new Error('Have to provide iasset oref when modify asset.');
-      }
-
-      const iassetUtxo = matchSingle(
-        await lucid.utxosByOutRef([modifyIAssetOref]),
-        (_) => new Error('Expected a single iasset UTXO'),
-      );
-
-      const iassetDatum = parseIAssetDatumOrThrow(
-        getInlineDatumOrThrow(iassetUtxo),
-      );
-
-      tx.readFrom([cdpRefScriptUtxo])
-        .collectFrom([iassetUtxo], serialiseCdpRedeemer('UpdateOrInsertAsset'))
-        .pay.ToContract(
-          createScriptAddress(network, sysParams.validatorHashes.cdpHash),
-          {
-            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,
-            }),
-          },
-          iassetUtxo.assets,
-        );
-
-      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]);
-      }
-    })
-    .with({ TextProposal: P.any }, () => {
-      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]);
-      }
-    })
-    .with(
-      { ModifyProtocolParams: { newParams: P.select() } },
-      (newProtocolParams) => {
-        tx.readFrom([govRefScriptUtxo])
-          .collectFrom([govUtxo], serialiseGovRedeemer('UpgradeGov'))
-          .pay.ToContract(
-            govUtxo.address,
-            {
-              kind: 'inline',
-              value: serialiseGovDatum({
-                ...govDatum,
-                protocolParams: newProtocolParams,
-                treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
-              }),
-            },
-            govUtxo.assets,
-          );
-      },
-    )
-    .with({ UpgradeProtocol: P.select() }, async (d) => {
-      const upgradeDetails = parseUpgradePaths(d.content);
-
-      const versionRecordTokenPolicyRefScriptUtxo = matchSingle(
-        await lucid.utxosByOutRef([
-          fromSystemParamsScriptRef(
-            sysParams.scriptReferences.versionRecordTokenPolicyRef,
-          ),
-        ]),
-        (_) =>
-          new Error(
-            'Expected a single version record token policy ref Script UTXO',
-          ),
-      );
-
-      const versionRecordNftVal = mkAssetsOf(
-        fromSystemParamsAsset(sysParams.executeParams.versionRecordToken),
-        1n,
-      );
-
-      tx.readFrom([govRefScriptUtxo, versionRecordTokenPolicyRefScriptUtxo])
-        .mintAssets(versionRecordNftVal, Data.void())
-        .pay.ToContract(
-          createScriptAddress(
-            network,
-            sysParams.validatorHashes.versionRegistryHash,
-          ),
-          {
-            kind: 'inline',
-            value: serialiseVersionRecordDatum({
-              upgradeId: upgradeDetails.upgradeId,
-              upgradePaths: new Map(
-                upgradeDetails.upgradePaths
-                  .entries()
-                  .map(([h1, h2]) => [h1, h2.upgradeSymbol]),
-              ),
-            }),
-          },
-          versionRecordNftVal,
-        )
-        .collectFrom([govUtxo], serialiseGovRedeemer('UpgradeGov'))
-        .pay.ToContract(
-          govUtxo.address,
-          {
-            kind: 'inline',
-            value: serialiseGovDatum({
-              ...govDatum,
-              currentVersion: govDatum.currentVersion + 1n,
-              treasuryIndyWithdrawnAmt: newTreasuryWithdrawnIndyAmtCapped,
-            }),
-          },
-          govUtxo.assets,
-        );
-    })
-    .exhaustive();
-
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo])
-    .validFrom(Number(currentTime) - ONE_SECOND)
-    .validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND)
-    .collectFrom([executeUtxo], Data.void())
-    .mintAssets(
-      mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
-      Data.void(),
-    )
-    .addSigner(ownAddr);
-
-  return tx;
-}