@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/rob/transactions-mutated.ts

@@ -1,844 +0,0 @@
-import {
-  addAssets,
-  Data,
-  fromHex,
-  getInputIndices,
-  LucidEvolution,
-  OutRef,
-  toHex,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  addrDetails,
-  buildRedemptionsTx,
-  collectInterestTx,
-  createScriptAddress,
-  fromSystemParamsAsset,
-  fromSystemParamsScriptRef,
-  getInlineDatumOrThrow,
-  matchSingle,
-  SystemParams,
-  treasuryFeeTx,
-} from '../../src';
-import {
-  parseCollateralAssetDatumOrThrow,
-  parseIAssetDatumOrThrow,
-} from '../../src/contracts/iasset/types';
-import { match, P } from 'ts-pattern';
-import { parsePriceOracleDatum } from '../../src/contracts/price-oracle/types-new';
-import { unzip, zip } from 'fp-ts/lib/Array';
-import {
-  parseCdpDatumOrThrow,
-  serialiseCdpDatum,
-  serialiseCdpRedeemer,
-} from '../../src/contracts/cdp/types-new';
-import { parseInterestOracleDatum } from '../../src/contracts/interest-oracle/types-new';
-import {
-  calculateAccruedInterest,
-  calculateUnitaryInterestSinceOracleLastUpdated,
-} from '../../src/contracts/interest-oracle/helpers';
-import { mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
-import { oracleExpirationAwareValidity } from '../../src/contracts/price-oracle/helpers';
-import { calculateFeeFromRatio } from '../../src/utils/indigo-helpers';
-import {
-  serialiseCDPCreatorDatum,
-  serialiseCDPCreatorRedeemer,
-} from '../../src/contracts/cdp-creator/types-new';
-import { retrieveAdjustedPrice } from '../../src/utils/oracle-helpers';
-
-// Unlike the real redeemRob function, this one allows building a transaction to redeem
-// using a delisted iAsset. Therefore, no price oracle is required.
-export async function testRedeemRob(
-  redemptionRobsData: [OutRef, bigint][],
-  priceOracleOutRef: OutRef | undefined,
-  iassetOutRef: OutRef,
-  collateralAssetOutRef: OutRef,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  pythMessage?: string,
-): Promise<TxBuilder> {
-  const robScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef),
-    ]),
-    (_) => new Error('Expected a single ROB Ref Script UTXO'),
-  );
-
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOutRef]),
-    (_) => new Error('Expected a single IAsset UTXO'),
-  );
-
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const collateralAssetUtxo = matchSingle(
-    await lucid.utxosByOutRef([collateralAssetOutRef]),
-    (_) => new Error('Expected a single collateral asset UTXO'),
-  );
-
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const [adjustedPrice, priceOracleUtxo] = await retrieveAdjustedPrice(
-    iassetDatum.assetName,
-    collateralAssetDatum.collateralAsset,
-    collateralAssetDatum.priceInfo,
-    collateralAssetDatum.extraDecimals,
-    priceOracleOutRef,
-    pythMessage,
-    sysParams.pythConfig,
-    lucid,
-  );
-
-  const [robsToRedeemOutRefs, robRedemptionIAssetAmt] =
-    unzip(redemptionRobsData);
-
-  const redemptionRobs = await lucid
-    .utxosByOutRef(robsToRedeemOutRefs)
-    .then((val) => zip(val, robRedemptionIAssetAmt));
-
-  const allRefInputs = [
-    robScriptRefUtxo,
-    iassetUtxo,
-    collateralAssetUtxo,
-    ...(priceOracleUtxo == null ? [] : [priceOracleUtxo]),
-  ];
-
-  const refInputIdxs = getInputIndices(allRefInputs, allRefInputs);
-
-  const tx = buildRedemptionsTx(
-    redemptionRobs,
-    iassetDatum.assetName,
-    collateralAssetDatum.collateralAsset,
-    adjustedPrice,
-    iassetDatum.redemptionReimbursementRatio,
-    sysParams,
-    lucid.newTx(),
-    0n,
-    refInputIdxs[2],
-    refInputIdxs[1],
-    priceOracleOutRef !== undefined
-      ? { OracleRefInputIdx: refInputIdxs[3] }
-      : 'OracleVoid',
-  );
-
-  const transaction = lucid
-    .newTx()
-    .validTo(lucid.slotToUnixTime(lucid.currentSlot()))
-    .readFrom(allRefInputs)
-    .compose(tx);
-
-  if (priceOracleUtxo != null) {
-    transaction.readFrom([priceOracleUtxo]);
-  }
-
-  return transaction;
-}
-
-export async function redeemWithCdpCreate(
-  redemptionRobsData: [OutRef, bigint][],
-  collateralAmount: bigint,
-  mintedAmount: bigint,
-  sysParams: SystemParams,
-  cdpCreatorOref: OutRef,
-  iassetOref: OutRef,
-  collateralAssetOref: OutRef,
-  priceOracleOref: OutRef,
-  interestOracleOref: OutRef,
-  treasuryOref: OutRef,
-  lucid: LucidEvolution,
-): Promise<TxBuilder> {
-  const network = lucid.config().network!;
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const [pkh, skh] = await addrDetails(lucid);
-
-  const treasuryRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury Ref Script UTXO'),
-  );
-
-  const robScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef),
-    ]),
-    (_) => new Error('Expected a single ROB Ref Script UTXO'),
-  );
-
-  const cdpCreatorRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.cdpCreatorValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single cdp creator 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 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 collateral asset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
-  );
-
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  const cdpCreatorUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpCreatorOref]),
-    (_) => new Error('Expected a single CDP creator UTXO'),
-  );
-
-  match(collateralAssetDatum.priceInfo)
-    .with({ Delisted: P.any }, () => {
-      throw new Error("Can't open CDP of delisted asset");
-    })
-    .otherwise(() => {});
-
-  const cdpNftVal = mkAssetsOf(
-    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
-    1n,
-  );
-
-  const iassetClass = {
-    currencySymbol: fromHex(
-      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-    ),
-    tokenName: iassetDatum.assetName,
-  };
-
-  const debtMintingFee = calculateFeeFromRatio(
-    iassetDatum.debtMintingFeeRatio,
-    mintedAmount,
-  );
-
-  const iassetTokensVal = mkAssetsOf(iassetClass, mintedAmount);
-
-  const [robsToRedeemOutRefs, robRedemptionIAssetAmt] =
-    unzip(redemptionRobsData);
-
-  const redemptionRobs = await lucid
-    .utxosByOutRef(robsToRedeemOutRefs)
-    .then((val) => zip(val, robRedemptionIAssetAmt));
-
-  const allRefInputs = [
-    collateralAssetUtxo,
-    iassetUtxo,
-    priceOracleUtxo,
-    interestOracleUtxo,
-    // ref scripts
-    cdpCreatorRefScriptUtxo,
-    robScriptRefUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-    cdpAuthTokenPolicyRefScriptUtxo,
-    ...(debtMintingFee > 0n ? [treasuryRefScriptUtxo] : []),
-  ];
-
-  const refInputIdxs = getInputIndices(allRefInputs, allRefInputs);
-
-  const tx = buildRedemptionsTx(
-    redemptionRobs,
-    iassetDatum.assetName,
-    collateralAssetDatum.collateralAsset,
-    priceOracleDatum.price,
-    iassetDatum.redemptionReimbursementRatio,
-    sysParams,
-    lucid.newTx(),
-    0n,
-    refInputIdxs[0],
-    refInputIdxs[1],
-    { OracleRefInputIdx: refInputIdxs[2] },
-  );
-
-  const txValidity = oracleExpirationAwareValidity(
-    lucid,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expirationTime),
-  );
-
-  tx.validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    // Ref scripts
-    .readFrom(allRefInputs)
-    .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: mintedAmount,
-          cdpFees: {
-            ActiveCDPInterestTracking: {
-              lastSettled: currentTime,
-              unitaryInterestSnapshot:
-                calculateUnitaryInterestSinceOracleLastUpdated(
-                  currentTime,
-                  interestOracleDatum,
-                ) + interestOracleDatum.unitaryInterest,
-            },
-          },
-        }),
-      },
-      addAssets(
-        cdpNftVal,
-        mkAssetsOf(collateralAssetDatum.collateralAsset, collateralAmount),
-      ),
-    )
-    .pay.ToContract(
-      cdpCreatorUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseCDPCreatorDatum({
-          creatorInputOref: {
-            outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
-            txHash: fromHex(cdpCreatorUtxo.txHash),
-          },
-        }),
-      },
-      cdpCreatorUtxo.assets,
-    );
-
-  if (debtMintingFee > 0) {
-    await treasuryFeeTx(
-      iassetClass,
-      debtMintingFee,
-      0n,
-      lucid,
-      sysParams,
-      tx,
-      cdpCreatorUtxo,
-      treasuryOref,
-    );
-  }
-
-  tx.collectFrom([cdpCreatorUtxo], {
-    kind: 'self',
-    makeRedeemer: (inputIdx) => {
-      return serialiseCDPCreatorRedeemer({
-        CreateCDP: {
-          cdpOwner: fromHex(pkh.hash),
-          minted: mintedAmount,
-          collateralAmt: collateralAmount,
-          currentTime: currentTime,
-          creatorInputIdx: inputIdx,
-          creatorOutputIdx: BigInt(redemptionRobs.length) + 1n,
-          cdpOutputIdx: BigInt(redemptionRobs.length),
-          iassetRefInputIdx: refInputIdxs[1],
-          collateralAssetRefInputIdx: refInputIdxs[0],
-          interestOracleRefInputIdx: refInputIdxs[3],
-          priceOracleIdx: { OracleRefInputIdx: refInputIdxs[2] },
-        },
-      });
-    },
-  });
-
-  return tx;
-}
-
-export async function redeemWithCdpClose(
-  redemptionRobsData: [OutRef, bigint][],
-  cdpOref: OutRef,
-  iassetOref: OutRef,
-  collateralAssetOref: OutRef,
-  priceOracleOref: OutRef,
-  interestOracleOref: OutRef,
-  interestCollectorOref: OutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const robScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef),
-    ]),
-    (_) => new Error('Expected a single ROB Ref Script UTXO'),
-  );
-
-  const cdpRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp Ref Script UTXO'),
-  );
-
-  const interestCollectorRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.interestCollectionValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single interest collector 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([cdpOref]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const collateralAssetUtxo = matchSingle(
-    await lucid.utxosByOutRef([collateralAssetOref]),
-    (_) => new Error('Expected a single collateral asset UTXO'),
-  );
-  const collateralDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => 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 interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  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 [robsToRedeemOutRefs, robRedemptionIAssetAmt] =
-    unzip(redemptionRobsData);
-
-  const redemptionRobs = await lucid
-    .utxosByOutRef(robsToRedeemOutRefs)
-    .then((val) => zip(val, robRedemptionIAssetAmt));
-
-  const allRefInputs = [
-    collateralAssetUtxo,
-    iassetUtxo,
-    priceOracleUtxo,
-    interestOracleUtxo,
-    // ref scripts
-    robScriptRefUtxo,
-    cdpRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-    cdpAuthTokenPolicyRefScriptUtxo,
-  ];
-
-  const allAll = [
-    ...allRefInputs,
-    ...(interestAmt > 0n ? [interestCollectorRefScriptUtxo] : []),
-  ];
-  const refInputIdxs = getInputIndices(allRefInputs, allAll);
-
-  const tx = buildRedemptionsTx(
-    redemptionRobs,
-    iassetDatum.assetName,
-    collateralDatum.collateralAsset,
-    priceOracleDatum.price,
-    iassetDatum.redemptionReimbursementRatio,
-    sysParams,
-    lucid.newTx(),
-    0n,
-    refInputIdxs[0],
-    refInputIdxs[1],
-    { OracleRefInputIdx: refInputIdxs[2] },
-  );
-
-  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-  const validateTo = Math.min(
-    Number(BigInt(validateFrom) + sysParams.cdpParams.biasTime / 2n),
-    Number(priceOracleDatum.expirationTime - 1n * 1000n),
-  );
-
-  tx.validFrom(validateFrom)
-    .validTo(validateTo)
-    .readFrom(allRefInputs)
-    .mintAssets(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: collateralDatum.iasset,
-        },
-        -cdpDatum.mintedAmt,
-      ),
-      Data.void(),
-    )
-    .mintAssets(
-      mkAssetsOf(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken), -1n),
-      Data.void(),
-    )
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({ CloseCdp: { currentTime: currentTime } }),
-    )
-    // TODO: this is just a placeholder
-    .setMinFee(3_000_000n);
-
-  if (!cdpDatum.cdpOwner) {
-    throw new Error('Expected active CDP');
-  }
-
-  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
-
-  if (interestAmt > 0n) {
-    await collectInterestTx(
-      mkAssetsOf(
-        {
-          currencySymbol: fromHex(
-            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          ),
-          tokenName: collateralDatum.iasset,
-        },
-        interestAmt,
-      ),
-      lucid,
-      sysParams,
-      tx,
-      interestCollectorOref,
-    );
-  }
-
-  return tx;
-}
-
-export async function redeemWithCdpAdjust(
-  redemptionRobsData: [OutRef, bigint][],
-  /// cdp adjust params
-  collateralAdjustment: bigint,
-  debtAdjustment: bigint,
-  cdpOref: OutRef,
-  iassetOref: OutRef,
-  collateralAssetOref: OutRef,
-  priceOracleOref: OutRef,
-  interestOracleOref: OutRef,
-  treasuryOref: OutRef,
-  interestCollectorOref: OutRef,
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const robScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef),
-    ]),
-    (_) => new Error('Expected a single ROB Ref Script UTXO'),
-  );
-
-  const cdpRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single cdp 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 interestCollectorRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.interestCollectionValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single interest collector Ref Script UTXO'),
-  );
-
-  const treasuryRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.treasuryValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single treasury 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 collateral asset UTXO'),
-  );
-  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
-    getInlineDatumOrThrow(collateralAssetUtxo),
-  );
-
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
-  );
-
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error('Expected a single interest oracle UTXO'),
-  );
-  const interestOracleDatum = parseInterestOracleDatum(
-    getInlineDatumOrThrow(interestOracleUtxo),
-  );
-
-  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;
-
-  let treasuryFee = 0n;
-
-  // when mint
-  if (debtAdjustment > 0n) {
-    treasuryFee += calculateFeeFromRatio(
-      iassetDatum.debtMintingFeeRatio,
-      debtAdjustment,
-    );
-  }
-
-  const [robsToRedeemOutRefs, robRedemptionIAssetAmt] =
-    unzip(redemptionRobsData);
-
-  const redemptionRobs = await lucid
-    .utxosByOutRef(robsToRedeemOutRefs)
-    .then((val) => zip(val, robRedemptionIAssetAmt));
-
-  const allRefInputs = [
-    collateralAssetUtxo,
-    iassetUtxo,
-    priceOracleUtxo,
-    interestOracleUtxo,
-    // ref scripts
-    robScriptRefUtxo,
-    cdpRefScriptUtxo,
-    iAssetTokenPolicyRefScriptUtxo,
-  ];
-
-  const allAll = [
-    ...allRefInputs,
-    ...(interestAmt > 0n ? [interestCollectorRefScriptUtxo] : []),
-    ...(treasuryFee > 0n ? [treasuryRefScriptUtxo] : []),
-  ];
-  const refInputIdxs = getInputIndices(allRefInputs, allAll);
-
-  const tx = buildRedemptionsTx(
-    redemptionRobs,
-    iassetDatum.assetName,
-    collateralAssetDatum.collateralAsset,
-    priceOracleDatum.price,
-    iassetDatum.redemptionReimbursementRatio,
-    sysParams,
-    lucid.newTx(),
-    0n,
-    refInputIdxs[0],
-    refInputIdxs[1],
-    { OracleRefInputIdx: refInputIdxs[2] },
-  );
-
-  const txValidity = oracleExpirationAwareValidity(
-    lucid,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expirationTime),
-  );
-
-  tx.validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    .readFrom(allRefInputs)
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({
-        AdjustCdp: {
-          currentTime: currentTime,
-          debtAdjustment: debtAdjustment,
-          collateralAdjustment,
-          priceOracleIdx: { OracleRefInputIdx: refInputIdxs[2] },
-        },
-      }),
-    )
-    .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));
-
-  const iAssetAc = {
-    currencySymbol: fromHex(
-      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-    ),
-    tokenName: iassetDatum.assetName,
-  };
-
-  if (mintedAmountChange !== 0n) {
-    const iassetTokensVal = mkAssetsOf(iAssetAc, mintedAmountChange);
-
-    tx.mintAssets(iassetTokensVal, Data.void());
-  }
-
-  if (interestAmt > 0n) {
-    await collectInterestTx(
-      mkAssetsOf(iAssetAc, interestAmt),
-      lucid,
-      sysParams,
-      tx,
-      interestCollectorOref,
-    );
-  }
-
-  if (treasuryFee > 0n) {
-    await treasuryFeeTx(
-      iAssetAc,
-      treasuryFee,
-      0n,
-      lucid,
-      sysParams,
-      tx,
-      cdpOref,
-      treasuryOref,
-    );
-  }
-
-  return tx;
-}