@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/rob/transactions-mutated.ts

@@ -0,0 +1,853 @@
+import {
+  addAssets,
+  Data,
+  fromHex,
+  getInputIndices,
+  LucidEvolution,
+  OutRef,
+  slotToUnixTime,
+  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,
+  currentSlot: number,
+  sysParams: SystemParams,
+  pythMessage?: string,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+
+  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],
+    priceOracleUtxo !== undefined ? refInputIdxs[3] : null,
+  );
+
+  const transaction = lucid
+    .newTx()
+    .validTo(slotToUnixTime(network, 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,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, 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],
+    refInputIdxs[2],
+  );
+
+  const txValidity = oracleExpirationAwareValidity(
+    currentSlot,
+    Number(sysParams.cdpCreatorParams.biasTime),
+    Number(priceOracleDatum.expirationTime),
+    network,
+  );
+
+  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,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, 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],
+    refInputIdxs[2],
+  );
+
+  const validateFrom = slotToUnixTime(network, 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,
+  currentSlot: number,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, 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],
+    refInputIdxs[2],
+  );
+
+  const txValidity = oracleExpirationAwareValidity(
+    currentSlot,
+    Number(sysParams.cdpCreatorParams.biasTime),
+    Number(priceOracleDatum.expirationTime),
+    network,
+  );
+
+  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;
+}