@indigo-labs/indigo-sdk 0.5.5 → 0.5.6

package/tests/cdp/transactions-mutated.ts

@@ -1,1733 +0,0 @@
-import {
-  addAssets,
-  Data,
-  fromHex,
-  LucidEvolution,
-  Credential,
-  OutRef,
-  toHex,
-  TxBuilder,
-  UTxO,
-  getInputIndices,
-  credentialToAddress,
-  validatorToScriptHash,
-  credentialToRewardAddress,
-  scriptHashToCredential,
-} from '@lucid-evolution/lucid';
-import {
-  fromSystemParamsAsset,
-  fromSystemParamsScriptRef,
-  SystemParams,
-} from '../../src/types/system-params';
-import {
-  addrDetails,
-  calculateMinCollateralCappedIAssetRedemptionAmt,
-  createScriptAddress,
-  getInlineDatumOrThrow,
-  matchSingle,
-  mkPriceOracleValidator,
-  mkTreasuryValidatorFromSP,
-  ONE_SECOND,
-  PriceOracleParams,
-  treasuryFeeTx,
-} from '../../src';
-import {
-  parseCdpDatumOrThrow,
-  serialiseCdpDatum,
-  serialiseCdpRedeemer,
-  serialiseRedeemCdpWithdrawalRedeemer,
-} from '../../src/contracts/cdp/types-new';
-import {
-  parseCollateralAssetDatumOrThrow,
-  parseIAssetDatumOrThrow,
-} from '../../src/contracts/iasset/types';
-import {
-  parsePriceOracleDatum,
-  serialisePriceOracleDatum,
-  serialisePriceOracleRedeemer,
-} from '../../src/contracts/price-oracle/types-new';
-import { parseInterestOracleDatum } from '../../src/contracts/interest-oracle/types-new';
-import { parseGovDatumOrThrow } from '../../src/contracts/gov/types-new';
-import { match, P } from 'ts-pattern';
-import {
-  calculateAccruedInterest,
-  calculateUnitaryInterestSinceOracleLastUpdated,
-} from '../../src/contracts/interest-oracle/helpers';
-import { calculateFeeFromRatio } from '../../src/utils/indigo-helpers';
-import {
-  AssetClass,
-  assetClassValueOf,
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { bigintMin } from '../../src/utils/bigint-utils';
-import { oracleExpirationAwareValidity } from '../../src/contracts/price-oracle/helpers';
-import {
-  findAllNecessaryOrefs,
-  findCdp,
-  findPriceOracleFromCollateralAsset,
-} from './cdp-queries';
-import { collectInterestTx } from '../../src/contracts/interest-collection/transactions';
-import { findCollateralAsset, findIAsset } from '../queries/iasset-queries';
-import { findInterestOracle } from '../queries/interest-oracle-queries';
-import { AssetInfo } from '../endpoints/initialize';
-import { LucidContext } from '../test-helpers';
-import { option as O, function as F } from 'fp-ts';
-import { findPriceOracle } from '../price-oracle/price-oracle-queries';
-import { findRandomNonAdminInterestCollector } from '../../src/contracts/interest-collection/queries';
-import {
-  serialiseCDPCreatorDatum,
-  serialiseCDPCreatorRedeemer,
-} from '../../src/contracts/cdp-creator/types-new';
-import {
-  CollectInterestVariation,
-  testCollectInterest,
-} from '../interest-collection/transactions-mutated';
-import { findRandomTreasuryUtxoWithOnlyAda } from '../../src/contracts/treasury/queries';
-import {
-  Rational,
-  rationalFloor,
-  rationalFromInt,
-  rationalMul,
-} from '../../src/types/rational';
-import { retrieveAdjustedPrice } from '../../src/utils/oracle-helpers';
-import * as Core from '@evolution-sdk/evolution';
-
-export async function mutatedRedeemCdp(
-  /**
-   * When the goal is to redeem the maximum possible, just pass in the total minted amount of the CDP.
-   * The logic will automatically cap the amount to the max.
-   */
-  attemptedRedemptionIAssetAmt: bigint,
-  cdpOref: OutRef,
-  iassetOref: OutRef,
-  collateralAssetOref: OutRef,
-  priceOracleOref: OutRef | undefined,
-  interestOracleOref: OutRef,
-  interestCollectorOref: OutRef,
-  govOref: OutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  pythMessage?: string,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const cdpRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const cdpRedeemRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.cdpRedeemValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp redeem Ref Script UTXO'),
-  );
-
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await lucid.utxosByOutRef([collateralAssetOref]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const isDelisted = match(collateralAssetDatum.priceInfo)
-    .with({ Delisted: P.any }, () => true)
-    .otherwise(() => false);
-
-  if (!isDelisted && priceOracleOref === undefined) {
-    throw new Error('Missing price oracle');
-  }
-
-  const [adjustedPrice, priceOracleUtxo] = await retrieveAdjustedPrice(
-    iassetDatum.assetName,
-    collateralAssetDatum.collateralAsset,
-    collateralAssetDatum.priceInfo,
-    collateralAssetDatum.extraDecimals,
-    priceOracleOref,
-    pythMessage,
-    sysParams.pythConfig,
-    lucid,
-  );
-
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error('Expected a single gov UTXO'),
-  );
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-
-  const interestAmt = match(cdpDatum.cdpFees)
-    .with({ FrozenCDPAccumulatedFees: P.any }, () => {
-      throw new Error('CDP fees wrong');
-    })
-    .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      return calculateAccruedInterest(
-        currentTime,
-        interest.unitaryInterestSnapshot,
-        cdpDatum.mintedAmt,
-        interest.lastSettled,
-        interestOracleDatum,
-      );
-    })
-    .exhaustive();
-
-  const collateralAmt = assetClassValueOf(
-    cdpUtxo.assets,
-    cdpDatum.collateralAsset,
-  );
-
-  const totalCdpDebt = cdpDatum.mintedAmt + interestAmt;
-
-  const [isPartial, redemptionIAssetAmt] = (() => {
-    const res = calculateMinCollateralCappedIAssetRedemptionAmt(
-      collateralAmt,
-      totalCdpDebt,
-      adjustedPrice,
-      collateralAssetDatum.redemptionRatio,
-      iassetDatum.redemptionReimbursementRatio,
-      BigInt(collateralAssetDatum.minCollateralAmt),
-    );
-
-    const redemptionAmt = bigintMin(
-      attemptedRedemptionIAssetAmt,
-      res.cappedIAssetRedemptionAmt,
-    );
-
-    return [redemptionAmt < res.cappedIAssetRedemptionAmt, redemptionAmt];
-  })();
-
-  if (redemptionIAssetAmt <= 0) {
-    throw new Error("There's no iAssets available for redemption.");
-  }
-
-  const redemptionCollateralAmt = rationalFloor(
-    rationalMul(adjustedPrice, rationalFromInt(redemptionIAssetAmt)),
-  );
-
-  const isPublicRedemption =
-    !govDatum.protocolParams.cdpRedemptionRequiredSignature;
-
-  const partialRedemptionFee =
-    isPartial && isPublicRedemption
-      ? BigInt(sysParams.cdpRedeemParams.partialRedemptionExtraFeeLovelace)
-      : 0n;
-
-  const processingFee = calculateFeeFromRatio(
-    iassetDatum.redemptionProcessingFeeRatio,
-    redemptionIAssetAmt,
-  );
-
-  const reimburstmentFee = calculateFeeFromRatio(
-    iassetDatum.redemptionReimbursementRatio,
-    redemptionCollateralAmt,
-  );
-
-  const referenceScripts = [
-    cdpRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-    cdpRedeemRefScriptUtxo,
-  ];
-
-  const referenceInputs = [
-    iassetUtxo,
-    collateralAssetUtxo,
-    interestOracleUtxo,
-    govUtxo,
-  ];
-
-  const tx = lucid
-    .newTx()
-    // Ref Script
-    .readFrom(referenceScripts)
-    // Ref inputs
-    .readFrom(referenceInputs)
-    .collectFrom([cdpUtxo], serialiseCdpRedeemer('RedeemCdp'))
-    .mintAssets(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: iassetDatum.assetName,
-        },
-        interestAmt - redemptionIAssetAmt,
-      ),
-      Data.void(),
-    )
-    .pay.ToContract(
-      cdpUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          ...cdpDatum,
-          mintedAmt: totalCdpDebt - redemptionIAssetAmt,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                interestOracleDatum.unitaryInterest +
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ),
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpUtxo.assets,
-        mkLovelacesOf(-redemptionCollateralAmt),
-        mkLovelacesOf(reimburstmentFee),
-      ),
-    );
-
-  if (priceOracleUtxo !== undefined) {
-    const priceOracleDatum = parsePriceOracleDatum(
-      getInlineDatumOrThrow(priceOracleUtxo),
-    );
-    const txValidity = oracleExpirationAwareValidity(
-      lucid,
-      Number(sysParams.cdpCreatorParams.biasTime),
-      Number(priceOracleDatum.expirationTime),
-    );
-
-    referenceInputs.push(priceOracleUtxo);
-
-    tx.validFrom(txValidity.validFrom)
-      .validTo(txValidity.validTo)
-      .readFrom([priceOracleUtxo]);
-  } else {
-    const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-    const validateTo =
-      validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
-
-    tx.validFrom(validateFrom).validTo(validateTo);
-  }
-
-  // Trigger CDP Redeem Withdrawal validator
-  tx.withdraw(
-    credentialToRewardAddress(
-      lucid.config().network!,
-      scriptHashToCredential(sysParams.cdpParams.cdpRedeemValHash),
-    ),
-    0n,
-    serialiseRedeemCdpWithdrawalRedeemer({
-      cdpOutReference: {
-        txHash: fromHex(cdpUtxo.txHash),
-        outputIndex: BigInt(cdpUtxo.outputIndex),
-      },
-      currentTime: currentTime,
-      priceOracleIdx: priceOracleUtxo
-        ? {
-            OracleRefInputIdx: getInputIndices(
-              [priceOracleUtxo],
-              [...referenceInputs, ...referenceScripts],
-            )[0],
-          }
-        : 'OracleVoid',
-    }),
-  );
-
-  //TODO: Use a treasury input to save on ADA.
-  tx.pay.ToContract(
-    credentialToAddress(lucid.config().network!, {
-      hash: validatorToScriptHash(
-        mkTreasuryValidatorFromSP(sysParams.treasuryParams),
-      ),
-      type: 'Script',
-    }),
-    { kind: 'inline', value: Data.void() },
-    addAssets(
-      mkAssetsOf(cdpDatum.collateralAsset, processingFee),
-      mkLovelacesOf(partialRedemptionFee),
-    ),
-  );
-  if (interestAmt > 0n) {
-    await collectInterestTx(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: iassetDatum.assetName,
-        },
-        interestAmt,
-      ),
-      lucid,
-      sysParams,
-      tx,
-      interestCollectorOref,
-    );
-  }
-
-  return tx;
-}
-
-export async function runOpenCdpDelisted(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  collateralAsset: AssetClass,
-  initialCollateral: bigint,
-  initialMint: bigint,
-): Promise<TxBuilder> {
-  const orefs = await findAllNecessaryOrefs(
-    context.lucid,
-    sysParams,
-    asset,
-    collateralAsset,
-  );
-
-  const network = context.lucid.config().network!;
-  const currentTime = BigInt(
-    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-  );
-
-  const [pkh, skh] = await addrDetails(context.lucid);
-
-  const cdpCreatorRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.cdpCreatorValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp creator Ref Script UTXO'),
-  );
-  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp auth token policy Ref Script UTXO'),
-  );
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  const iassetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.iasset.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.collateralAsset.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const interestOracleUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.interestOracleUtxo]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const cdpCreatorUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.cdpCreatorUtxo]),
-    (_) => new Error('Expected a single CDP creator UTXO'),
-  );
-
-  const cdpNftVal = mkAssetsOf(
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    1n,
-  );
-
-  const iassetClass = {
-    currencySymbol: fromHex(
-      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-    ),
-    tokenName: iassetDatum.assetName,
-  };
-
-  const iassetTokensVal = mkAssetsOf(iassetClass, initialMint);
-
-  const refScripts: UTxO[] = [
-    cdpCreatorRefScriptUtxo,
-    cdpAuthTokenPolicyRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-  ];
-
-  const referenceInputs: UTxO[] = [
-    interestOracleUtxo,
-    iassetUtxo,
-    collateralAssetUtxo,
-  ];
-
-  const tx = context.lucid
-    .newTx()
-    .readFrom(refScripts)
-    .readFrom(referenceInputs)
-    .mintAssets(cdpNftVal, Data.void())
-    .mintAssets(iassetTokensVal, Data.void())
-    .pay.ToContract(
-      createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          cdpOwner: fromHex(pkh.hash),
-          iasset: iassetDatum.assetName,
-          collateralAsset: collateralAssetDatum.collateralAsset,
-          mintedAmt: initialMint,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ) + interestOracleDatum.unitaryInterest,
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpNftVal,
-        mkAssetsOf(collateralAssetDatum.collateralAsset, initialCollateral),
-      ),
-    )
-    .pay.ToContract(
-      cdpCreatorUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCDPCreatorDatum({
-          creatorInputOref: {
-            outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
-            txHash: fromHex(cdpCreatorUtxo.txHash),
-          },
-        }),
-      },
-      cdpCreatorUtxo.assets,
-    );
-
-  const debtMintingFee = calculateFeeFromRatio(
-    iassetDatum.debtMintingFeeRatio,
-    initialMint,
-  );
-
-  const treasuryRefScriptUtxo =
-    debtMintingFee > 0
-      ? await treasuryFeeTx(
-          iassetClass,
-          debtMintingFee,
-          0n,
-          context.lucid,
-          sysParams,
-          tx,
-          cdpCreatorUtxo,
-          orefs.treasuryUtxo,
-        )
-      : undefined;
-
-  const validFrom = context.lucid.slotToUnixTime(
-    context.lucid.currentSlot() - 1,
-  );
-  const validTo = validFrom + Number(sysParams.cdpCreatorParams.biasTime);
-
-  tx.validFrom(validFrom).validTo(validTo);
-
-  // We need to take into account the treasury ref script.
-  const refInputsIndices = getInputIndices(referenceInputs, [
-    ...referenceInputs,
-    ...refScripts,
-    ...(treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []),
-  ]);
-
-  tx.collectFrom([cdpCreatorUtxo], {
-    kind: 'self',
-    makeRedeemer: (inputIdx) => {
-      return serialiseCDPCreatorRedeemer({
-        CreateCDP: {
-          cdpOwner: fromHex(pkh.hash),
-          minted: initialMint,
-          collateralAmt: initialCollateral,
-          currentTime: currentTime,
-          creatorInputIdx: inputIdx,
-          creatorOutputIdx: 1n,
-          cdpOutputIdx: 0n,
-          iassetRefInputIdx: refInputsIndices[1],
-          collateralAssetRefInputIdx: refInputsIndices[2],
-          interestOracleRefInputIdx: refInputsIndices[0],
-          priceOracleIdx: 'OracleVoid',
-        },
-      });
-    },
-  });
-
-  return tx;
-}
-
-export async function runOpenCdpAndUpdateOracle(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  collateralAsset: AssetClass,
-  initialCollateral: bigint,
-  initialMint: bigint,
-  oracleParams: PriceOracleParams,
-  newPrice: Rational,
-): Promise<TxBuilder> {
-  const orefs = await findAllNecessaryOrefs(
-    context.lucid,
-    sysParams,
-    asset,
-    collateralAsset,
-  );
-
-  const network = context.lucid.config().network!;
-  const currentTime = BigInt(
-    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-  );
-
-  const [pkh, skh] = await addrDetails(context.lucid);
-
-  const oracleValidator = mkPriceOracleValidator(oracleParams);
-
-  const cdpCreatorRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.cdpCreatorValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp creator Ref Script UTXO'),
-  );
-  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp auth token policy Ref Script UTXO'),
-  );
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  const iassetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.iasset.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.collateralAsset.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
-    context.lucid,
-    orefs.collateralAsset,
-  );
-
-  if (!priceOracleUtxo) throw new Error('Expected a price oracle');
-
-  const interestOracleUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.interestOracleUtxo]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const cdpCreatorUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.cdpCreatorUtxo]),
-    (_) => new Error('Expected a single CDP creator UTXO'),
-  );
-
-  const cdpNftVal = mkAssetsOf(
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    1n,
-  );
-
-  const iassetClass = {
-    currencySymbol: fromHex(
-      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-    ),
-    tokenName: iassetDatum.assetName,
-  };
-
-  const iassetTokensVal = mkAssetsOf(iassetClass, initialMint);
-
-  const refScripts: UTxO[] = [
-    cdpCreatorRefScriptUtxo,
-    cdpAuthTokenPolicyRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-  ];
-
-  const referenceInputs: UTxO[] = [
-    interestOracleUtxo,
-    iassetUtxo,
-    collateralAssetUtxo,
-  ];
-
-  const tx = context.lucid
-    .newTx()
-    .validFrom(Number(currentTime - oracleParams.biasTime) + ONE_SECOND)
-    .validTo(Number(currentTime + oracleParams.biasTime) - ONE_SECOND)
-    .attach.SpendingValidator(oracleValidator)
-    .readFrom(refScripts)
-    .readFrom(referenceInputs)
-    .mintAssets(cdpNftVal, Data.void())
-    .mintAssets(iassetTokensVal, Data.void())
-    .collectFrom(
-      [priceOracleUtxo],
-      serialisePriceOracleRedeemer({
-        currentTime: currentTime,
-        newPrice: newPrice,
-      }),
-    )
-    .pay.ToContract(
-      priceOracleUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePriceOracleDatum({
-          price: newPrice,
-          expirationTime: currentTime + oracleParams.expirationPeriod,
-          auxiliaryData: Core.Data.fromCBORHex(Data.void()),
-        }),
-      },
-      priceOracleUtxo.assets,
-    )
-    .pay.ToContract(
-      createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          cdpOwner: fromHex(pkh.hash),
-          iasset: iassetDatum.assetName,
-          collateralAsset: collateralAssetDatum.collateralAsset,
-          mintedAmt: initialMint,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ) + interestOracleDatum.unitaryInterest,
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpNftVal,
-        mkAssetsOf(collateralAssetDatum.collateralAsset, initialCollateral),
-      ),
-    )
-    .pay.ToContract(
-      cdpCreatorUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCDPCreatorDatum({
-          creatorInputOref: {
-            outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
-            txHash: fromHex(cdpCreatorUtxo.txHash),
-          },
-        }),
-      },
-      cdpCreatorUtxo.assets,
-    )
-    .addSignerKey(pkh.hash);
-
-  const debtMintingFee = calculateFeeFromRatio(
-    iassetDatum.debtMintingFeeRatio,
-    initialMint,
-  );
-
-  const treasuryRefScriptUtxo =
-    debtMintingFee > 0
-      ? await treasuryFeeTx(
-          iassetClass,
-          debtMintingFee,
-          0n,
-          context.lucid,
-          sysParams,
-          tx,
-          cdpCreatorUtxo,
-          orefs.treasuryUtxo,
-        )
-      : undefined;
-
-  // We need to take into account the treasury ref script as well.
-  const refInputsIndices = getInputIndices(referenceInputs, [
-    ...referenceInputs,
-    ...refScripts,
-    ...(treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []),
-  ]);
-
-  tx.collectFrom([cdpCreatorUtxo], {
-    kind: 'self',
-    makeRedeemer: (inputIdx) => {
-      return serialiseCDPCreatorRedeemer({
-        CreateCDP: {
-          cdpOwner: fromHex(pkh.hash),
-          minted: initialMint,
-          collateralAmt: initialCollateral,
-          currentTime: currentTime,
-          creatorInputIdx: inputIdx,
-          creatorOutputIdx: 2n,
-          cdpOutputIdx: 1n,
-          iassetRefInputIdx: refInputsIndices[1],
-          collateralAssetRefInputIdx: refInputsIndices[2],
-          interestOracleRefInputIdx: refInputsIndices[0],
-          priceOracleIdx: { OracleOutputIdx: 0n },
-        },
-      });
-    },
-  });
-
-  return tx;
-}
-
-export async function runTestAdjustCdpDelisted(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  collateralAsset: AssetClass,
-  collateralAdjustment: bigint,
-  debtAdjustment: bigint,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(
-    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-  );
-  const [pkh, skh] = await addrDetails(context.lucid);
-
-  const cdp = await findCdp(
-    context.lucid,
-    sysParams.validatorHashes.cdpHash,
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    pkh.hash,
-    skh,
-  );
-
-  const cdpRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const cdpUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([cdp.utxo]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const iassetOutput = await findIAsset(
-    context.lucid,
-    sysParams.validatorHashes.iassetHash,
-    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
-    asset,
-  );
-
-  const iassetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([iassetOutput.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetOutput = await findCollateralAsset(
-    context.lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    asset,
-    collateralAsset,
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([collateralAssetOutput.utxo]),
-    (_) => new Error('Expected a single collateral asset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const interestOracleUtxo = await findInterestOracle(
-    context.lucid,
-    collateralAssetDatum.interestOracleNft,
-  );
-
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const interestCollectorUtxo = await findRandomNonAdminInterestCollector(
-    context.lucid,
-    sysParams,
-  );
-
-  const validateFrom = context.lucid.slotToUnixTime(
-    context.lucid.currentSlot() - 1,
-  );
-  const validateTo =
-    validateFrom + Number(sysParams.cdpParams.biasTime) - 60_000;
-
-  const interestAmt = match(cdpDatum.cdpFees)
-    .with({ FrozenCDPAccumulatedFees: P.any }, () => {
-      throw new Error('CDP fees wrong');
-    })
-    .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      return calculateAccruedInterest(
-        currentTime,
-        interest.unitaryInterestSnapshot,
-        cdpDatum.mintedAmt,
-        interest.lastSettled,
-        interestOracleDatum,
-      );
-    })
-    .exhaustive();
-
-  const mintedAmountChange = debtAdjustment + interestAmt;
-
-  const tx = context.lucid
-    .newTx()
-    .validFrom(validateFrom)
-    .validTo(validateTo)
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({
-        AdjustCdp: {
-          currentTime: currentTime,
-          debtAdjustment,
-          collateralAdjustment,
-          priceOracleIdx: 'OracleVoid',
-        },
-      }),
-    )
-    .readFrom([cdpRefScriptUtxo])
-    .readFrom([iassetUtxo, collateralAssetUtxo, interestOracleUtxo])
-    .pay.ToContract(
-      cdpUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          ...cdpDatum,
-          mintedAmt: cdpDatum.mintedAmt + mintedAmountChange,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ) + interestOracleDatum.unitaryInterest,
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpUtxo.assets,
-        mkAssetsOf(cdpDatum.collateralAsset, collateralAdjustment),
-      ),
-    );
-
-  if (!cdpDatum.cdpOwner) {
-    throw new Error('Expected active CDP');
-  }
-
-  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
-
-  if (mintedAmountChange !== 0n) {
-    const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-      await context.lucid.utxosByOutRef([
-        fromSystemParamsScriptRef(
-          sysParams.scriptReferences.iAssetTokenPolicyRef,
-        ),
-      ]),
-      (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-    );
-
-    const iassetTokensVal = mkAssetsOf(
-      {
-        currencySymbol: fromHex(
-          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-        ),
-        tokenName: iassetDatum.assetName,
-      },
-      mintedAmountChange,
-    );
-
-    tx.readFrom([iAssetTokenPolicyRefScriptUtxo]).mintAssets(
-      iassetTokensVal,
-      Data.void(),
-    );
-  }
-
-  const iAssetAc = {
-    currencySymbol: fromHex(
-      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-    ),
-    tokenName: iassetDatum.assetName,
-  };
-
-  if (interestAmt > 0n) {
-    await collectInterestTx(
-      mkAssetsOf(iAssetAc, interestAmt),
-      context.lucid,
-      sysParams,
-      tx,
-      interestCollectorUtxo,
-    );
-  }
-
-  let treasuryFee = 0n;
-
-  if (debtAdjustment > 0n) {
-    const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
-      context.lucid,
-      sysParams,
-    );
-
-    treasuryFee += calculateFeeFromRatio(
-      iassetDatum.debtMintingFeeRatio,
-      debtAdjustment,
-    );
-
-    if (treasuryFee > 0n) {
-      await treasuryFeeTx(
-        iAssetAc,
-        treasuryFee,
-        0n,
-        context.lucid,
-        sysParams,
-        tx,
-        cdpUtxo,
-        treasuryUtxo,
-      );
-    }
-  }
-
-  return tx;
-}
-
-export async function runTestDepositCdpWithInterestVar(
-  context: LucidContext,
-  sysParams: SystemParams,
-  iasset: string,
-  collateralAsset: AssetClass,
-  interestCollectorUtxo: UTxO,
-  interestVariation: CollectInterestVariation,
-
-  amount: bigint = 1_000_000n,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(
-    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-  );
-  const [pkh, skh] = await addrDetails(context.lucid);
-
-  const cdp = await findCdp(
-    context.lucid,
-    sysParams.validatorHashes.cdpHash,
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    pkh.hash,
-    skh,
-  );
-
-  const cdpRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const cdpUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([cdp.utxo]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const iassetOutput = await findIAsset(
-    context.lucid,
-    sysParams.validatorHashes.iassetHash,
-    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
-    iasset,
-  );
-
-  const iassetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([iassetOutput.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetOutput = await findCollateralAsset(
-    context.lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    iasset,
-    collateralAsset,
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([collateralAssetOutput.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-
-  const interestOracleUtxo = await findInterestOracle(
-    context.lucid,
-    collateralAssetOutput.datum.interestOracleNft,
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const validateFrom = context.lucid.slotToUnixTime(
-    context.lucid.currentSlot() - 1,
-  );
-  const validateTo =
-    validateFrom + Number(sysParams.cdpParams.biasTime) - 60_000;
-
-  const interestAmt = match(cdpDatum.cdpFees)
-    .with({ FrozenCDPAccumulatedFees: P.any }, () => {
-      throw new Error('CDP fees wrong');
-    })
-    .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      return calculateAccruedInterest(
-        currentTime,
-        interest.unitaryInterestSnapshot,
-        cdpDatum.mintedAmt,
-        interest.lastSettled,
-        interestOracleDatum,
-      );
-    })
-    .exhaustive();
-
-  const mintedAmountChange = interestAmt;
-
-  const tx = context.lucid
-    .newTx()
-    .validFrom(validateFrom)
-    .validTo(validateTo)
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({
-        AdjustCdp: {
-          currentTime: currentTime,
-          debtAdjustment: 0n,
-          collateralAdjustment: amount,
-          priceOracleIdx: 'OracleVoid',
-        },
-      }),
-    )
-    .readFrom([cdpRefScriptUtxo])
-    .readFrom([iassetUtxo, collateralAssetUtxo, interestOracleUtxo])
-    .pay.ToContract(
-      cdpUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          ...cdpDatum,
-          mintedAmt: cdpDatum.mintedAmt + mintedAmountChange,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ) + interestOracleDatum.unitaryInterest,
-            },
-          },
-        }),
-      },
-      addAssets(cdpUtxo.assets, mkLovelacesOf(amount)),
-    );
-
-  if (!cdpDatum.cdpOwner) {
-    throw new Error('Expected active CDP');
-  }
-
-  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
-
-  if (mintedAmountChange !== 0n) {
-    const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-      await context.lucid.utxosByOutRef([
-        fromSystemParamsScriptRef(
-          sysParams.scriptReferences.iAssetTokenPolicyRef,
-        ),
-      ]),
-      (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-    );
-
-    const iassetTokensVal = mkAssetsOf(
-      {
-        currencySymbol: fromHex(
-          sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-        ),
-        tokenName: iassetDatum.assetName,
-      },
-      mintedAmountChange,
-    );
-
-    tx.readFrom([iAssetTokenPolicyRefScriptUtxo]).mintAssets(
-      iassetTokensVal,
-      Data.void(),
-    );
-  }
-
-  if (interestAmt > 0n) {
-    await testCollectInterest(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: iassetDatum.assetName,
-        },
-        interestAmt,
-      ),
-      context.lucid,
-      sysParams,
-      tx,
-      interestCollectorUtxo,
-      interestVariation,
-    );
-  }
-
-  return tx;
-}
-
-export async function runCloseCdpWrongOracle(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  iasset: string,
-  wrongAsset: string,
-  collateralAsset: AssetClass,
-): Promise<TxBuilder> {
-  const [pkh, skh] = await addrDetails(lucid);
-
-  const cdp = await findCdp(
-    lucid,
-    sysParams.validatorHashes.cdpHash,
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    pkh.hash,
-    skh,
-  );
-  const orefs = await findAllNecessaryOrefs(
-    lucid,
-    sysParams,
-    iasset,
-    collateralAsset,
-  );
-
-  const priceOracleOref = await findPriceOracleFromCollateralAsset(
-    lucid,
-    orefs.collateralAsset,
-  );
-
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const cdpRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp auth token policy Ref Script UTXO'),
-  );
-
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdp.utxo]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([orefs.iasset.utxo]),
-    (_) => new Error('Expected a single iasset UTXO'),
-  );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref!]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
-  );
-
-  const wrongCollateral = await findCollateralAsset(
-    lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    wrongAsset,
-    collateralAsset,
-  );
-
-  const wrongInterestOracleUtxo = await findInterestOracle(
-    lucid,
-    wrongCollateral.datum.interestOracleNft,
-  );
-
-  const wrongInterestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(wrongInterestOracleUtxo),
-  );
-
-  const txValidity = oracleExpirationAwareValidity(
-    lucid,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expirationTime),
-  );
-
-  const tx = lucid
-    .newTx()
-    .readFrom([
-      cdpRefScriptUtxo,
-      iAssetTokenPolicyRefScriptUtxo,
-      cdpAuthTokenPolicyRefScriptUtxo,
-    ])
-    .readFrom([wrongCollateral.utxo, wrongInterestOracleUtxo])
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    .mintAssets(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: iassetDatum.assetName,
-        },
-        -cdpDatum.mintedAmt,
-      ),
-      Data.void(),
-    )
-    .mintAssets(
-      mkAssetsOf(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken), -1n),
-      Data.void(),
-    )
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({ CloseCdp: { currentTime: currentTime } }),
-    );
-
-  if (!cdpDatum.cdpOwner) {
-    throw new Error('Expected active CDP');
-  }
-
-  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
-
-  const interestAmt = match(cdpDatum.cdpFees)
-    .with({ FrozenCDPAccumulatedFees: P.any }, () => {
-      throw new Error('CDP fees wrong');
-    })
-    .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      return calculateAccruedInterest(
-        currentTime,
-        interest.unitaryInterestSnapshot,
-        cdpDatum.mintedAmt,
-        interest.lastSettled,
-        wrongInterestOracleDatum,
-      );
-    })
-    .exhaustive();
-
-  if (interestAmt > 0n) {
-    await collectInterestTx(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: cdpDatum.iasset,
-        },
-        interestAmt,
-      ),
-      lucid,
-      sysParams,
-      tx,
-      orefs.interestCollectorUtxo,
-    );
-  }
-
-  return tx;
-}
-
-export async function runRedeemCdpWrongOracle(
-  context: LucidContext,
-  sysParams: SystemParams,
-  assetInfo: AssetInfo,
-  wrongAssetInfo: AssetInfo,
-  collateralAsset: AssetClass,
-  pkh: string,
-  skh: Credential | undefined,
-): Promise<TxBuilder> {
-  const cdp = await findCdp(
-    context.lucid,
-    sysParams.validatorHashes.cdpHash,
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    pkh,
-    skh,
-  );
-
-  const cdpRedeemRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.cdpRedeemValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp redeem Ref Script UTXO'),
-  );
-
-  const orefs = await findAllNecessaryOrefs(
-    context.lucid,
-    sysParams,
-    assetInfo.iassetTokenNameAscii,
-    collateralAsset,
-  );
-
-  const wrongIasset = await findIAsset(
-    context.lucid,
-    sysParams.validatorHashes.iassetHash,
-    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
-    wrongAssetInfo.iassetTokenNameAscii,
-  );
-
-  const wrongCollateral = await findCollateralAsset(
-    context.lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    wrongAssetInfo.iassetTokenNameAscii,
-    collateralAsset,
-  );
-
-  const wrongInterestOracleUtxo = await findInterestOracle(
-    context.lucid,
-    wrongCollateral.datum.interestOracleNft,
-  );
-
-  const wrongInterestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(wrongInterestOracleUtxo),
-  );
-
-  const wrongPriceOracleUtxo = await findPriceOracle(
-    context.lucid,
-    match(wrongCollateral.datum.priceInfo)
-      .with({ OracleNft: P.select() }, (oracleNft) => oracleNft)
-      .otherwise(() => {
-        throw new Error('Expected active oracle');
-      }),
-  );
-
-  const wrongPriceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(wrongPriceOracleUtxo),
-  );
-
-  const currentTime = BigInt(
-    context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-  );
-
-  const cdpRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  const cdpUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([cdp.utxo]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const govUtxo = matchSingle(
-    await context.lucid.utxosByOutRef([orefs.govUtxo]),
-    (_) => new Error('Expected a single gov UTXO'),
-  );
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-
-  const interestAmt = match(cdpDatum.cdpFees)
-    .with({ FrozenCDPAccumulatedFees: P.any }, () => {
-      throw new Error('CDP fees wrong');
-    })
-    .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      return calculateAccruedInterest(
-        currentTime,
-        interest.unitaryInterestSnapshot,
-        cdpDatum.mintedAmt,
-        interest.lastSettled,
-        wrongInterestOracleDatum,
-      );
-    })
-    .exhaustive();
-
-  const collateralAmt = assetClassValueOf(
-    cdpUtxo.assets,
-    cdpDatum.collateralAsset,
-  );
-
-  const totalCdpDebt = cdpDatum.mintedAmt + interestAmt;
-
-  const [isPartial, redemptionIAssetAmt] = (() => {
-    const res = calculateMinCollateralCappedIAssetRedemptionAmt(
-      collateralAmt,
-      totalCdpDebt,
-      wrongPriceOracleDatum.price,
-      wrongCollateral.datum.redemptionRatio,
-      wrongIasset.datum.redemptionReimbursementRatio,
-      BigInt(wrongCollateral.datum.minCollateralAmt),
-    );
-
-    const redemptionAmt = bigintMin(
-      cdp.datum.mintedAmt,
-      res.cappedIAssetRedemptionAmt,
-    );
-
-    return [redemptionAmt < res.cappedIAssetRedemptionAmt, redemptionAmt];
-  })();
-
-  if (redemptionIAssetAmt <= 0) {
-    throw new Error("There's no iAssets available for redemption.");
-  }
-
-  const redemptionCollateralAmt = rationalFloor(
-    rationalMul(
-      wrongPriceOracleDatum.price,
-      rationalFromInt(redemptionIAssetAmt),
-    ),
-  );
-
-  const processingFee = calculateFeeFromRatio(
-    wrongIasset.datum.redemptionProcessingFeeRatio,
-    redemptionCollateralAmt,
-  );
-  const reimburstmentFee = calculateFeeFromRatio(
-    wrongIasset.datum.redemptionReimbursementRatio,
-    redemptionCollateralAmt,
-  );
-
-  const txValidity = oracleExpirationAwareValidity(
-    context.lucid,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(wrongPriceOracleDatum.expirationTime),
-  );
-
-  const referenceInputs = [
-    wrongIasset.utxo,
-    wrongCollateral.utxo,
-    wrongPriceOracleUtxo,
-    wrongInterestOracleUtxo,
-    govUtxo,
-  ];
-
-  const referenceScripts = [
-    cdpRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-    cdpRedeemRefScriptUtxo,
-  ];
-
-  const tx = context.lucid.newTx().readFrom(referenceScripts);
-
-  const interestCollectorRefScriptUtxo =
-    interestAmt > 0n
-      ? await collectInterestTx(
-          mkAssetsOf(
-            {
-              currencySymbol: fromHex(
-                sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-              ),
-              tokenName: cdpDatum.iasset,
-            },
-            interestAmt,
-          ),
-          context.lucid,
-          sysParams,
-          tx,
-          orefs.interestCollectorUtxo,
-        )
-      : undefined;
-
-  // We need to take into account the interest collector ref script as well.
-  const priceOracleIdx = getInputIndices(
-    [wrongPriceOracleUtxo],
-    [
-      ...referenceInputs,
-      ...referenceScripts,
-      ...(interestCollectorRefScriptUtxo != null
-        ? [interestCollectorRefScriptUtxo]
-        : []),
-    ],
-  )[0];
-
-  tx.readFrom(referenceInputs)
-    // Trigger CDP Redeem Withdrawal validator
-    .withdraw(
-      credentialToRewardAddress(
-        context.lucid.config().network!,
-        scriptHashToCredential(sysParams.cdpParams.cdpRedeemValHash),
-      ),
-      0n,
-      serialiseRedeemCdpWithdrawalRedeemer({
-        cdpOutReference: {
-          txHash: fromHex(cdpUtxo.txHash),
-          outputIndex: BigInt(cdpUtxo.outputIndex),
-        },
-        currentTime: currentTime,
-        priceOracleIdx: { OracleRefInputIdx: priceOracleIdx },
-      }),
-    )
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    .collectFrom([cdpUtxo], serialiseCdpRedeemer('RedeemCdp'))
-    .mintAssets(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: cdpDatum.iasset,
-        },
-        interestAmt - redemptionIAssetAmt,
-      ),
-      Data.void(),
-    )
-    .pay.ToContract(
-      cdpUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCdpDatum({
-          ...cdpDatum,
-          mintedAmt: totalCdpDebt - redemptionIAssetAmt,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                wrongInterestOracleDatum.unitaryInterest +
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  wrongInterestOracleDatum,
-                ),
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpUtxo.assets,
-        mkAssetsOf(
-          cdpDatum.collateralAsset,
-          -redemptionCollateralAmt + reimburstmentFee,
-        ),
-      ),
-    );
-
-  const partialRedemptionFee = F.pipe(
-    govDatum.protocolParams.cdpRedemptionRequiredSignature,
-    O.fromNullable,
-    O.match(
-      // When public redemptions
-      () => {
-        return isPartial
-          ? BigInt(sysParams.cdpRedeemParams.partialRedemptionExtraFeeLovelace)
-          : 0n;
-      },
-      // When private redemptions
-      (requiredSignature) => {
-        tx.addSignerKey(toHex(requiredSignature));
-        return 0n;
-      },
-    ),
-  );
-
-  //TODO: Use a treasury input to save on ADA.
-  tx.pay.ToContract(
-    credentialToAddress(context.lucid.config().network!, {
-      hash: validatorToScriptHash(
-        mkTreasuryValidatorFromSP(sysParams.treasuryParams),
-      ),
-      type: 'Script',
-    }),
-    { kind: 'inline', value: Data.void() },
-    addAssets(
-      mkAssetsOf(cdpDatum.collateralAsset, processingFee),
-      mkLovelacesOf(partialRedemptionFee),
-    ),
-  );
-
-  return tx;
-}