@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/cdp/transactions.ts

@@ -1,10 +1,15 @@
 import {
   addAssets,
   Assets,
+  credentialToRewardAddress,
   Data,
+  fromHex,
+  getInputIndices,
   LucidEvolution,
   OutRef,
+  scriptHashToCredential,
   slotToUnixTime,
+  toHex,
   TxBuilder,
   UTxO,
 } from '@lucid-evolution/lucid';
@@ -17,59 +22,73 @@ import {
   addrDetails,
   createScriptAddress,
   getInlineDatumOrThrow,
-  resolveUtxo,
-  UtxoOrOutRef,
 } from '../../utils/lucid-utils';
 import { matchSingle } from '../../utils/utils';
-import {
-  CDPContent,
-  parseCdpDatumOrThrow,
-  parseIAssetDatumOrThrow,
-  serialiseCdpDatum,
-  serialiseCdpRedeemer,
-} from './types';
-import { parsePriceOracleDatum } from '../price-oracle/types';
-import { parseInterestOracleDatum } from '../interest-oracle/types';
-import { parseGovDatumOrThrow } from '../gov/types';
 import {
   calculateAccruedInterest,
   calculateUnitaryInterestSinceOracleLastUpdated,
-  computeInterestLovelacesFor100PercentCR,
 } from '../interest-oracle/helpers';
 import { oracleExpirationAwareValidity } from '../price-oracle/helpers';
 import { match, P } from 'ts-pattern';
-import { serialiseCDPCreatorRedeemer } from '../cdp-creator/types';
-import {
-  assetClassValueOf,
-  lovelacesAmt,
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '../../utils/value-helpers';
+
 import { calculateMinCollateralCappedIAssetRedemptionAmt } from './helpers';
-import { bigintMin } from '../../utils/bigint-utils';
-import { ocdMul } from '../../types/on-chain-decimal';
+import { bigintMax, bigintMin } from '../../utils/bigint-utils';
 import {
-  parseStabilityPoolDatum,
+  parseStabilityPoolDatumOrThrow,
   serialiseStabilityPoolDatum,
   serialiseStabilityPoolRedeemer,
 } from '../stability-pool/types-new';
 import { liquidationHelper } from '../stability-pool/helpers';
-import { array as A, function as F } from 'fp-ts';
-import { calculateFeeFromPercentage } from '../../utils/indigo-helpers';
-import { collectorFeeTx } from '../collector/transactions';
+import { array as A, function as F, option as O } from 'fp-ts';
+import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
+import { collectInterestTx } from '../interest-collection/transactions';
+import {
+  CDPContent,
+  parseCdpDatumOrThrow,
+  serialiseCdpDatum,
+  serialiseCdpRedeemer,
+  serialiseRedeemCdpWithdrawalRedeemer,
+} from './types-new';
+import { parseGovDatumOrThrow } from '../gov/types-new';
+import {
+  adaAssetClass,
+  assetClassValueOf,
+  mkAssetsOf,
+  negateAssets,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { parsePriceOracleDatum } from '../price-oracle/types-new';
+import { parseInterestOracleDatum } from '../interest-oracle/types-new';
+import {
+  serialiseCDPCreatorDatum,
+  serialiseCDPCreatorRedeemer,
+} from '../cdp-creator/types-new';
+import {
+  parseCollateralAssetDatumOrThrow,
+  parseIAssetDatumOrThrow,
+} from '../iasset/types';
 import { treasuryFeeTx } from '../treasury/transactions';
+import { attachOracle } from '../iasset/helpers';
+import {
+  rationalFloor,
+  rationalFromInt,
+  rationalMul,
+} from '../../types/rational';
+import { retrieveAdjustedPrice } from '../../utils/oracle-helpers';
 
 export async function openCdp(
   collateralAmount: bigint,
   mintedAmount: bigint,
   sysParams: SystemParams,
-  cdpCreator: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
+  cdpCreatorOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -101,40 +120,36 @@ export async function openCdp(
     (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
   );
 
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single iasset UTXO',
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOref]),
+    (_) => new Error('Expected a single iasset UTXO'),
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo),
   );
 
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single collateral asset UTXO'),
   );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
-  const interestOracleUtxo = await resolveUtxo(
-    interestOracle,
-    lucid,
-    'Expected a single interest oracle UTXO',
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  const cdpCreatorUtxo = await resolveUtxo(
-    cdpCreator,
-    lucid,
-    'Expected a single CDP creator UTXO',
+  const cdpCreatorUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpCreatorOref]),
+    (_) => new Error('Expected a single CDP creator UTXO'),
   );
 
-  match(iassetDatum.price)
+  match(collateralAssetDatum.priceInfo)
     .with({ Delisted: P.any }, () => {
       throw new Error("Can't open CDP of delisted asset");
     })
@@ -145,50 +160,41 @@ export async function openCdp(
     1n,
   );
 
-  const iassetTokensVal = mkAssetsOf(
-    {
-      currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-      tokenName: iassetDatum.assetName,
-    },
-    mintedAmount,
-  );
+  const iassetClass = {
+    currencySymbol: fromHex(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+    ),
+    tokenName: iassetDatum.assetName,
+  };
 
-  const txValidity = oracleExpirationAwareValidity(
-    currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
-  );
+  const iassetTokensVal = mkAssetsOf(iassetClass, mintedAmount);
+
+  const refScripts: UTxO[] = [
+    cdpCreatorRefScriptUtxo,
+    cdpAuthTokenPolicyRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+  ];
+
+  const referenceInputs: UTxO[] = [
+    interestOracleUtxo,
+    iassetUtxo,
+    collateralAssetUtxo,
+  ];
 
   const tx = lucid
     .newTx()
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    .readFrom([
-      cdpCreatorRefScriptUtxo,
-      cdpAuthTokenPolicyRefScriptUtxo,
-      iAssetTokenPolicyRefScriptUtxo,
-    ])
+    // Ref scripts
+    .readFrom(refScripts)
     .mintAssets(cdpNftVal, Data.void())
     .mintAssets(iassetTokensVal, Data.void())
-    .collectFrom(
-      [cdpCreatorUtxo],
-      serialiseCDPCreatorRedeemer({
-        CreateCDP: {
-          cdpOwner: pkh.hash,
-          minted: mintedAmount,
-          collateral: collateralAmount,
-          currentTime: currentTime,
-        },
-      }),
-    )
     .pay.ToContract(
       createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
       {
         kind: 'inline',
         value: serialiseCdpDatum({
-          cdpOwner: pkh.hash,
+          cdpOwner: fromHex(pkh.hash),
           iasset: iassetDatum.assetName,
+          collateralAsset: collateralAssetDatum.collateralAsset,
           mintedAmt: mintedAmount,
           cdpFees: {
             ActiveCDPInterestTracking: {
@@ -202,41 +208,115 @@ export async function openCdp(
           },
         }),
       },
-      addAssets(cdpNftVal, mkLovelacesOf(collateralAmount)),
+      addAssets(
+        cdpNftVal,
+        mkAssetsOf(collateralAssetDatum.collateralAsset, collateralAmount),
+      ),
     )
     .pay.ToContract(
       cdpCreatorUtxo.address,
-      { kind: 'inline', value: Data.void() },
+      {
+        kind: 'inline',
+        value: serialiseCDPCreatorDatum({
+          creatorInputOref: {
+            outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
+            txHash: fromHex(cdpCreatorUtxo.txHash),
+          },
+        }),
+      },
       cdpCreatorUtxo.assets,
-    )
-    .readFrom([priceOracleUtxo, interestOracleUtxo, iassetUtxo])
-    .addSignerKey(pkh.hash);
+    );
 
-  const debtMintingFee = calculateFeeFromPercentage(
-    iassetDatum.debtMintingFeePercentage,
-    (mintedAmount * priceOracleDatum.price.getOnChainInt) / 1_000_000n,
+  const { interval, referenceInputs: refInputs } = await attachOracle(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    priceOracleOref,
+    pythStateOref,
+    pythMessage,
+    sysParams.pythConfig,
+    sysParams.cdpCreatorParams.biasTime,
+    currentSlot,
+    lucid,
+    tx,
   );
 
-  if (debtMintingFee > 0) {
-    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collector);
-  }
+  // Set the validity interval for the transaction
+  tx.validFrom(interval.validFrom).validTo(interval.validTo);
+
+  // Read from the reference inputs
+  referenceInputs.push(...refInputs);
+
+  tx.readFrom(referenceInputs);
+
+  const debtMintingFee = calculateFeeFromRatio(
+    iassetDatum.debtMintingFeeRatio,
+    mintedAmount,
+  );
+
+  const treasuryRefScriptUtxo =
+    debtMintingFee > 0
+      ? await treasuryFeeTx(
+          iassetClass,
+          debtMintingFee,
+          0n,
+          lucid,
+          sysParams,
+          tx,
+          cdpCreatorUtxo,
+          treasuryOref,
+        )
+      : 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: mintedAmount,
+          collateralAmt: collateralAmount,
+          currentTime: currentTime,
+          creatorInputIdx: inputIdx,
+          creatorOutputIdx: 1n,
+          cdpOutputIdx: 0n,
+          iassetRefInputIdx: refInputsIndices[1],
+          collateralAssetRefInputIdx: refInputsIndices[2],
+          interestOracleRefInputIdx: refInputsIndices[0],
+          priceOracleIdx:
+            priceOracleOref !== undefined
+              ? { OracleRefInputIdx: refInputsIndices[3] }
+              : 'OracleVoid',
+        },
+      });
+    },
+  });
 
   return tx;
 }
 
-async function adjustCdp(
-  collateralAmount: bigint,
-  mintAmount: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+export async function adjustCdp(
+  collateralAdjustment: bigint,
+  debtAdjustment: bigint,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
+  interestCollectorOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -248,97 +328,178 @@ async function adjustCdp(
     (_) => new Error('Expected a single cdp Ref Script UTXO'),
   );
 
-  const cdpUtxo = await resolveUtxo(cdp, lucid, 'Expected a single cdp UTXO');
+  const cdpUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
 
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single iasset UTXO',
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOref]),
+    (_) => new Error('Expected a single iasset UTXO'),
   );
+
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo),
   );
 
-  const govUtxo = await resolveUtxo(gov, lucid, 'Expected a single gov UTXO');
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single collateral asset UTXO'),
   );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
-  const interestOracleUtxo = await resolveUtxo(
-    interestOracle,
-    lucid,
-    'Expected a single interest oracle UTXO',
+  const iAssetAc = {
+    currencySymbol: fromHex(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+    ),
+    tokenName: iassetDatum.assetName,
+  };
+
+  const isMintOrWithdraw = debtAdjustment > 0n || collateralAdjustment < 0n;
+
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  match(iassetDatum.price)
-    .with({ Delisted: P.any }, () => {
-      throw new Error("Can't adjust CDP of delisted asset");
-    })
-    .otherwise(() => {});
-
-  const txValidity = oracleExpirationAwareValidity(
-    currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
-  );
-
-  const interestAdaAmt = match(cdpDatum.cdpFees)
+  const interestAmt = match(cdpDatum.cdpFees)
     .with({ FrozenCDPAccumulatedFees: P.any }, () => {
       throw new Error('CDP fees wrong');
     })
     .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      const interestPaymentIAssetAmt = calculateAccruedInterest(
+      return calculateAccruedInterest(
         currentTime,
         interest.unitaryInterestSnapshot,
         cdpDatum.mintedAmt,
         interest.lastSettled,
         interestOracleDatum,
       );
-
-      return (
-        (interestPaymentIAssetAmt * priceOracleDatum.price.getOnChainInt) /
-        1_000_000n
-      );
     })
     .exhaustive();
 
-  const newCollateralAmount = collateralAmount - interestAdaAmt;
+  const mintedAmountChange = debtAdjustment + interestAmt;
 
-  const tx = lucid
-    .newTx()
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
+  const referenceScripts = [cdpRefScriptUtxo];
+  let referenceInputs = [iassetUtxo, collateralAssetUtxo, interestOracleUtxo];
+
+  let treasuryFee = 0n;
+
+  const tx = lucid.newTx().readFrom(referenceScripts);
+
+  if (isMintOrWithdraw) {
+    const { interval, referenceInputs: oracleRefInputs } = await attachOracle(
+      iassetDatum.assetName,
+      collateralAssetDatum.collateralAsset,
+      collateralAssetDatum.priceInfo,
+      priceOracleOref,
+      pythStateOref,
+      pythMessage,
+      sysParams.pythConfig,
+      sysParams.cdpParams.biasTime,
+      currentSlot,
+      lucid,
+      tx,
+    );
+
+    referenceInputs = [...oracleRefInputs, ...referenceInputs];
+
+    // Set the validity interval for the transaction
+    tx.validFrom(interval.validFrom).validTo(interval.validTo);
+  } else {
+    // Set the validity interval for the transaction
+    tx.validFrom(
+      Number(currentTime - BigInt(sysParams.cdpParams.biasTime) / 2n),
+    ).validTo(Number(currentTime + BigInt(sysParams.cdpParams.biasTime) / 2n));
+  }
+
+  // when mint
+  if (debtAdjustment > 0n) {
+    treasuryFee += calculateFeeFromRatio(
+      iassetDatum.debtMintingFeeRatio,
+      debtAdjustment,
+    );
+  }
+
+  const treasuryRefScriptUtxo =
+    treasuryFee > 0
+      ? await treasuryFeeTx(
+          iAssetAc,
+          treasuryFee,
+          0n,
+          lucid,
+          sysParams,
+          tx,
+          cdpUtxo,
+          treasuryOref,
+        )
+      : undefined;
+
+  const interestCollectorRefScriptUtxo =
+    interestAmt > 0n
+      ? await collectInterestTx(
+          mkAssetsOf(iAssetAc, interestAmt),
+          lucid,
+          sysParams,
+          tx,
+          interestCollectorOref,
+        )
+      : undefined;
+
+  const iAssetTokenPolicyRefScriptUtxo =
+    mintedAmountChange !== 0n
+      ? matchSingle(
+          await lucid.utxosByOutRef([
+            fromSystemParamsScriptRef(
+              sysParams.scriptReferences.iAssetTokenPolicyRef,
+            ),
+          ]),
+          (_) =>
+            new Error('Expected a single iasset token policy Ref Script UTXO'),
+        )
+      : undefined;
+
+  // We need to take into account the treasury, interest collector
+  // and iAsset policy ref scripts as well.
+  const refInputsIndices = getInputIndices(referenceInputs, [
+    ...referenceInputs,
+    ...referenceScripts,
+    ...(treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []),
+    ...(interestCollectorRefScriptUtxo != null
+      ? [interestCollectorRefScriptUtxo]
+      : []),
+    ...(iAssetTokenPolicyRefScriptUtxo != null
+      ? [iAssetTokenPolicyRefScriptUtxo]
+      : []),
+  ]);
+
+  tx.readFrom(referenceInputs)
     .collectFrom(
       [cdpUtxo],
       serialiseCdpRedeemer({
         AdjustCdp: {
-          collateralAmtChange: collateralAmount,
           currentTime: currentTime,
-          mintedAmtChange: mintAmount,
+          debtAdjustment: debtAdjustment,
+          collateralAdjustment,
+          priceOracleIdx:
+            priceOracleOref !== undefined
+              ? { OracleRefInputIdx: refInputsIndices[0] }
+              : 'OracleVoid',
         },
       }),
     )
-    .readFrom([cdpRefScriptUtxo])
-    .readFrom([iassetUtxo, govUtxo, priceOracleUtxo, interestOracleUtxo])
     .pay.ToContract(
       cdpUtxo.address,
       {
         kind: 'inline',
         value: serialiseCdpDatum({
           ...cdpDatum,
-          mintedAmt: cdpDatum.mintedAmt + mintAmount,
+          mintedAmt: cdpDatum.mintedAmt + mintedAmountChange,
           cdpFees: {
             ActiveCDPInterestTracking: {
               lastSettled: currentTime,
@@ -351,83 +512,38 @@ async function adjustCdp(
           },
         }),
       },
-      addAssets(cdpUtxo.assets, mkLovelacesOf(newCollateralAmount)),
-    );
-
-  if (!cdpDatum.cdpOwner) {
-    throw new Error('Expected active CDP');
-  }
-
-  tx.addSignerKey(cdpDatum.cdpOwner);
-
-  if (mintAmount !== 0n) {
-    const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-      await lucid.utxosByOutRef([
-        fromSystemParamsScriptRef(
-          sysParams.scriptReferences.iAssetTokenPolicyRef,
-        ),
-      ]),
-      (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
+      addAssets(
+        cdpUtxo.assets,
+        mkAssetsOf(cdpDatum.collateralAsset, collateralAdjustment),
+      ),
     );
 
-    const iassetTokensVal = mkAssetsOf(
-      {
-        currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-        tokenName: iassetDatum.assetName,
-      },
-      mintAmount,
-    );
+  if (mintedAmountChange !== 0n) {
+    const iassetTokensVal = mkAssetsOf(iAssetAc, mintedAmountChange);
 
-    tx.readFrom([iAssetTokenPolicyRefScriptUtxo]).mintAssets(
+    tx.readFrom([iAssetTokenPolicyRefScriptUtxo as UTxO]).mintAssets(
       iassetTokensVal,
       Data.void(),
     );
   }
 
-  const interestCollectorAdaAmt = calculateFeeFromPercentage(
-    iassetDatum.interestCollectorPortionPercentage,
-    interestAdaAmt,
-  );
-  const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
-
-  if (interestTreasuryAdaAmt > 0) {
-    await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
-  }
-
-  let collectorFee = interestCollectorAdaAmt;
-
-  // when mint
-  if (mintAmount > 0n) {
-    collectorFee += calculateFeeFromPercentage(
-      iassetDatum.debtMintingFeePercentage,
-      (mintAmount * priceOracleDatum.price.getOnChainInt) / 1_000_000n,
-    );
-  }
-
-  // when withdraw
-  if (collateralAmount < 0n) {
-    collectorFee += calculateFeeFromPercentage(
-      govDatum.protocolParams.collateralFeePercentage,
-      -collateralAmount,
-    );
+  if (!cdpDatum.cdpOwner) {
+    throw new Error('Expected active CDP');
   }
 
-  if (collectorFee > 0n) {
-    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collector);
-  }
+  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
 
   return tx;
 }
 
 export async function depositCdp(
   amount: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
+  interestCollectorOref: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -435,13 +551,13 @@ export async function depositCdp(
   return adjustCdp(
     amount,
     0n,
-    cdp,
-    iasset,
-    priceOracle,
-    interestOracle,
-    collector,
-    gov,
-    treasury,
+    cdpOref,
+    iassetOref,
+    collateralAssetOref,
+    undefined,
+    interestOracleOref,
+    treasuryOref,
+    interestCollectorOref,
     params,
     lucid,
     currentSlot,
@@ -450,71 +566,78 @@ export async function depositCdp(
 
 export async function withdrawCdp(
   amount: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
+  interestCollectorOref: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   return adjustCdp(
     -amount,
     0n,
-    cdp,
-    iasset,
-    priceOracle,
-    interestOracle,
-    collector,
-    gov,
-    treasury,
+    cdpOref,
+    iassetOref,
+    collateralAssetOref,
+    priceOracleOref,
+    interestOracleOref,
+    treasuryOref,
+    interestCollectorOref,
     params,
     lucid,
     currentSlot,
+    pythMessage,
+    pythStateOref,
   );
 }
 
 export async function mintCdp(
   amount: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
+  interestCollectorOref: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   return adjustCdp(
     0n,
     amount,
-    cdp,
-    iasset,
-    priceOracle,
-    interestOracle,
-    collector,
-    gov,
-    treasury,
+    cdpOref,
+    iassetOref,
+    collateralAssetOref,
+    priceOracleOref,
+    interestOracleOref,
+    treasuryOref,
+    interestCollectorOref,
     params,
     lucid,
     currentSlot,
+    pythMessage,
+    pythStateOref,
   );
 }
 
 export async function burnCdp(
   amount: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  interestOracleOref: OutRef,
+  treasuryOref: OutRef,
+  interestCollectorOref: OutRef,
   params: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -522,13 +645,13 @@ export async function burnCdp(
   return adjustCdp(
     0n,
     -amount,
-    cdp,
-    iasset,
-    priceOracle,
-    interestOracle,
-    collector,
-    gov,
-    treasury,
+    cdpOref,
+    iassetOref,
+    collateralAssetOref,
+    undefined,
+    interestOracleOref,
+    treasuryOref,
+    interestCollectorOref,
     params,
     lucid,
     currentSlot,
@@ -536,13 +659,10 @@ export async function burnCdp(
 }
 
 export async function closeCdp(
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  gov: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  collateralAssetOref: OutRef,
+  interestOracleOref: OutRef,
+  interestCollectorOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
@@ -575,45 +695,30 @@ export async function closeCdp(
     (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
   );
 
-  const cdpUtxo = await resolveUtxo(cdp, lucid, 'Expected a single cdp UTXO');
-  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single iasset UTXO',
+  const cdpUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
   );
-  const iassetDatum = parseIAssetDatumOrThrow(
-    getInlineDatumOrThrow(iassetUtxo),
-  );
-
-  const govUtxo = await resolveUtxo(gov, lucid, 'Expected a single gov UTXO');
-  const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
+  const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
 
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single collateral asset UTXO'),
   );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
+  const collateralDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
-  const interestOracleUtxo = await resolveUtxo(
-    interestOracle,
-    lucid,
-    'Expected a single interest oracle UTXO',
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  const txValidity = oracleExpirationAwareValidity(
-    currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
-  );
+  const validateFrom = slotToUnixTime(network, currentSlot - 1);
+  const validateTo = validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
 
   const tx = lucid
     .newTx()
@@ -622,14 +727,16 @@ export async function closeCdp(
       iAssetTokenPolicyRefScriptUtxo,
       cdpAuthTokenPolicyRefScriptUtxo,
     ])
-    .readFrom([iassetUtxo, govUtxo, priceOracleUtxo, interestOracleUtxo])
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
+    .readFrom([collateralAssetUtxo, interestOracleUtxo])
+    .validFrom(validateFrom)
+    .validTo(validateTo)
     .mintAssets(
       mkAssetsOf(
         {
-          currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
-          tokenName: iassetDatum.assetName,
+          currencySymbol: fromHex(
+            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
+          tokenName: collateralDatum.iasset,
         },
         -cdpDatum.mintedAmt,
       ),
@@ -648,47 +755,39 @@ export async function closeCdp(
     throw new Error('Expected active CDP');
   }
 
-  tx.addSignerKey(cdpDatum.cdpOwner);
+  tx.addSignerKey(toHex(cdpDatum.cdpOwner));
 
-  const interestAdaAmt = match(cdpDatum.cdpFees)
+  const interestAmt = match(cdpDatum.cdpFees)
     .with({ FrozenCDPAccumulatedFees: P.any }, () => {
       throw new Error('CDP fees wrong');
     })
     .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      const interestPaymentIAssetAmt = calculateAccruedInterest(
+      return calculateAccruedInterest(
         currentTime,
         interest.unitaryInterestSnapshot,
         cdpDatum.mintedAmt,
         interest.lastSettled,
         interestOracleDatum,
       );
-
-      return (
-        (interestPaymentIAssetAmt * priceOracleDatum.price.getOnChainInt) /
-        1_000_000n
-      );
     })
     .exhaustive();
 
-  const interestCollectorAdaAmt = calculateFeeFromPercentage(
-    iassetDatum.interestCollectorPortionPercentage,
-    interestAdaAmt,
-  );
-  const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
-
-  if (interestTreasuryAdaAmt > 0) {
-    await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
-  }
-
-  const collectorFee =
-    interestCollectorAdaAmt +
-    calculateFeeFromPercentage(
-      govDatum.protocolParams.collateralFeePercentage,
-      lovelacesAmt(cdpUtxo.assets) - interestAdaAmt,
+  if (interestAmt > 0n) {
+    await collectInterestTx(
+      mkAssetsOf(
+        {
+          currencySymbol: fromHex(
+            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
+          tokenName: collateralDatum.iasset,
+        },
+        interestAmt,
+      ),
+      lucid,
+      sysParams,
+      tx,
+      interestCollectorOref,
     );
-
-  if (collectorFee > 0n) {
-    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collector);
   }
 
   return tx;
@@ -700,15 +799,19 @@ export async function redeemCdp(
    * The logic will automatically cap the amount to the max.
    */
   attemptedRedemptionIAssetAmt: bigint,
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
+  interestCollectorOref: OutRef,
+  treasuryOref: OutRef,
+  govOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  _pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -720,6 +823,15 @@ export async function redeemCdp(
     (_) => 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(
@@ -729,73 +841,91 @@ export async function redeemCdp(
     (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
   );
 
-  const cdpUtxo = await resolveUtxo(cdp, lucid, 'Expected a single cdp UTXO');
+  const cdpUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
 
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single iasset UTXO',
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOref]),
+    (_) => new Error('Expected a single iasset UTXO'),
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo),
   );
 
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single collateral asset UTXO'),
   );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
-  const interestOracleUtxo = await resolveUtxo(
-    interestOracle,
+  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,
-    'Expected a single interest oracle UTXO',
+  );
+
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  const interestAdaAmt = match(cdpDatum.cdpFees)
+  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) => {
-      const interestPaymentIAssetAmt = calculateAccruedInterest(
+      return calculateAccruedInterest(
         currentTime,
         interest.unitaryInterestSnapshot,
         cdpDatum.mintedAmt,
         interest.lastSettled,
         interestOracleDatum,
       );
-
-      return ocdMul(
-        { getOnChainInt: interestPaymentIAssetAmt },
-        priceOracleDatum.price,
-      ).getOnChainInt;
     })
     .exhaustive();
 
-  const interestCollectorAdaAmt = calculateFeeFromPercentage(
-    iassetDatum.interestCollectorPortionPercentage,
-    interestAdaAmt,
+  const collateralAmt = assetClassValueOf(
+    cdpUtxo.assets,
+    cdpDatum.collateralAsset,
   );
-  const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
 
-  const collateralAmtMinusInterest =
-    lovelacesAmt(cdpUtxo.assets) - interestAdaAmt;
+  const totalCdpDebt = cdpDatum.mintedAmt + interestAmt;
 
   const [isPartial, redemptionIAssetAmt] = (() => {
     const res = calculateMinCollateralCappedIAssetRedemptionAmt(
-      collateralAmtMinusInterest,
-      cdpDatum.mintedAmt,
-      priceOracleDatum.price,
-      iassetDatum.redemptionRatio,
-      iassetDatum.redemptionReimbursementPercentage,
-      BigInt(sysParams.cdpParams.minCollateralInLovelace),
+      collateralAmt,
+      totalCdpDebt,
+      adjustedPrice,
+      collateralAssetDatum.redemptionRatio,
+      iassetDatum.redemptionReimbursementRatio,
+      BigInt(collateralAssetDatum.minCollateralAmt),
     );
 
     const redemptionAmt = bigintMin(
@@ -810,50 +940,162 @@ export async function redeemCdp(
     throw new Error("There's no iAssets available for redemption.");
   }
 
-  const redemptionLovelacesAmt = ocdMul(priceOracleDatum.price, {
-    getOnChainInt: redemptionIAssetAmt,
-  }).getOnChainInt;
-
-  const partialRedemptionFee = isPartial
-    ? BigInt(sysParams.cdpParams.partialRedemptionExtraFeeLovelace)
-    : 0n;
+  const redemptionCollateralAmt = rationalFloor(
+    rationalMul(adjustedPrice, rationalFromInt(redemptionIAssetAmt)),
+  );
 
-  const processingFee = calculateFeeFromPercentage(
-    iassetDatum.redemptionProcessingFeePercentage,
-    redemptionLovelacesAmt,
+  const processingFee = calculateFeeFromRatio(
+    iassetDatum.redemptionProcessingFeeRatio,
+    redemptionCollateralAmt,
   );
 
-  const reimburstmentFee = calculateFeeFromPercentage(
-    iassetDatum.redemptionReimbursementPercentage,
-    redemptionLovelacesAmt,
+  const reimburstmentFee = calculateFeeFromRatio(
+    iassetDatum.redemptionReimbursementRatio,
+    redemptionCollateralAmt,
   );
 
-  const txValidity = oracleExpirationAwareValidity(
-    currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
+  const referenceScripts = [
+    cdpRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+    cdpRedeemRefScriptUtxo,
+  ];
+
+  const referenceInputs = [
+    iassetUtxo,
+    collateralAssetUtxo,
+    interestOracleUtxo,
+    govUtxo,
+  ];
+
+  const tx = lucid.newTx().readFrom(referenceScripts);
+
+  if (priceOracleUtxo !== undefined) {
+    const priceOracleDatum = parsePriceOracleDatum(
+      getInlineDatumOrThrow(priceOracleUtxo),
+    );
+
+    const txValidity = oracleExpirationAwareValidity(
+      currentSlot,
+      Number(sysParams.cdpCreatorParams.biasTime),
+      Number(priceOracleDatum.expirationTime),
+      network,
+    );
+
+    referenceInputs.push(priceOracleUtxo);
+
+    tx.validFrom(txValidity.validFrom).validTo(txValidity.validTo);
+  } else {
+    const validateFrom = slotToUnixTime(network, currentSlot - 1);
+    const validateTo =
+      validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
+
+    tx.validFrom(validateFrom).validTo(validateTo);
+  }
+
+  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;
+      },
+    ),
   );
 
-  const tx = lucid
-    .newTx()
-    // Ref Script
-    .readFrom([cdpRefScriptUtxo, iAssetTokenPolicyRefScriptUtxo])
+  const treasuryRefScriptUtxo =
+    processingFee > 0n
+      ? await treasuryFeeTx(
+          cdpDatum.collateralAsset,
+          processingFee,
+          partialRedemptionFee,
+          lucid,
+          sysParams,
+          tx,
+          cdpOref,
+          treasuryOref,
+        )
+      : partialRedemptionFee > 0n
+        ? await treasuryFeeTx(
+            adaAssetClass,
+            partialRedemptionFee,
+            0n,
+            lucid,
+            sysParams,
+            tx,
+            cdpOref,
+            treasuryOref,
+          )
+        : undefined;
+
+  const interestCollectorRefScriptUtxo =
+    interestAmt > 0n
+      ? await collectInterestTx(
+          mkAssetsOf(
+            {
+              currencySymbol: fromHex(
+                sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+              ),
+              tokenName: iassetDatum.assetName,
+            },
+            interestAmt,
+          ),
+          lucid,
+          sysParams,
+          tx,
+          interestCollectorOref,
+        )
+      : undefined;
+
+  // We need to take into account the treasury and interest collector ref scripts as well.
+  const refInputsIndices = getInputIndices(referenceInputs, [
+    ...referenceInputs,
+    ...referenceScripts,
+    ...(treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []),
+    ...(interestCollectorRefScriptUtxo != null
+      ? [interestCollectorRefScriptUtxo]
+      : []),
+  ]);
+
+  tx
     // Ref inputs
-    .readFrom([iassetUtxo, priceOracleUtxo, interestOracleUtxo])
-    .validFrom(txValidity.validFrom)
-    .validTo(txValidity.validTo)
-    .collectFrom(
-      [cdpUtxo],
-      serialiseCdpRedeemer({ RedeemCdp: { currentTime: currentTime } }),
+    .readFrom(referenceInputs)
+    // Trigger CDP Redeem Withdrawal validator
+    .withdraw(
+      credentialToRewardAddress(
+        lucid.config().network!,
+        scriptHashToCredential(sysParams.cdpParams.cdpRedeemValHash),
+      ),
+      0n,
+      serialiseRedeemCdpWithdrawalRedeemer({
+        cdpOutReference: {
+          txHash: fromHex(cdpUtxo.txHash),
+          outputIndex: BigInt(cdpUtxo.outputIndex),
+        },
+        currentTime: currentTime,
+        priceOracleIdx:
+          priceOracleOref !== undefined
+            ? { OracleRefInputIdx: refInputsIndices[4] }
+            : 'OracleVoid',
+      }),
     )
+    .collectFrom([cdpUtxo], serialiseCdpRedeemer('RedeemCdp'))
     .mintAssets(
       mkAssetsOf(
         {
-          currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          currencySymbol: fromHex(
+            sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
           tokenName: iassetDatum.assetName,
         },
-        -redemptionIAssetAmt,
+        interestAmt - redemptionIAssetAmt,
       ),
       Data.void(),
     )
@@ -863,7 +1105,7 @@ export async function redeemCdp(
         kind: 'inline',
         value: serialiseCdpDatum({
           ...cdpDatum,
-          mintedAmt: cdpDatum.mintedAmt - redemptionIAssetAmt,
+          mintedAmt: totalCdpDebt - redemptionIAssetAmt,
           cdpFees: {
             ActiveCDPInterestTracking: {
               lastSettled: currentTime,
@@ -879,33 +1121,27 @@ export async function redeemCdp(
       },
       addAssets(
         cdpUtxo.assets,
-        mkLovelacesOf(-redemptionLovelacesAmt),
-        mkLovelacesOf(reimburstmentFee),
-        mkLovelacesOf(-interestAdaAmt),
+        mkAssetsOf(
+          cdpDatum.collateralAsset,
+          -redemptionCollateralAmt + reimburstmentFee,
+        ),
       ),
     );
 
-  await collectorFeeTx(
-    processingFee + partialRedemptionFee + interestCollectorAdaAmt,
-    lucid,
-    sysParams,
-    tx,
-    collector,
-  );
-
-  await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
-
   return tx;
 }
 
 export async function freezeCdp(
-  cdp: UtxoOrOutRef,
-  iasset: UtxoOrOutRef,
-  priceOracle: UtxoOrOutRef,
-  interestOracle: UtxoOrOutRef,
+  cdpOref: OutRef,
+  iassetOref: OutRef,
+  collateralAssetOref: OutRef,
+  priceOracleOref: OutRef | undefined,
+  interestOracleOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
   currentSlot: number,
+  pythMessage: string | undefined = undefined,
+  pythStateOref: OutRef | undefined = undefined,
 ): Promise<TxBuilder> {
   const network = lucid.config().network!;
   const currentTime = BigInt(slotToUnixTime(network, currentSlot));
@@ -916,137 +1152,145 @@ export async function freezeCdp(
     ]),
     (_) => new Error('Expected a single cdp Ref Script UTXO'),
   );
-  const cdpUtxo = await resolveUtxo(cdp, lucid, 'Expected a single cdp UTXO');
+  const cdpUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
 
-  const iassetUtxo = await resolveUtxo(
-    iasset,
-    lucid,
-    'Expected a single iasset UTXO',
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOref]),
+    (_) => new Error('Expected a single iasset UTXO'),
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo),
   );
-
-  const priceOracleUtxo = await resolveUtxo(
-    priceOracle,
-    lucid,
-    'Expected a single price oracle UTXO',
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single collateral asset UTXO'),
   );
-  const priceOracleDatum = parsePriceOracleDatum(
-    getInlineDatumOrThrow(priceOracleUtxo),
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
   );
 
-  const interestOracleUtxo = await resolveUtxo(
-    interestOracle,
+  const [adjustedPrice, _] = await retrieveAdjustedPrice(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    collateralAssetDatum.extraDecimals,
+    priceOracleOref,
+    pythMessage,
+    sysParams.pythConfig,
     lucid,
-    'Expected a single interest oracle UTXO',
+  );
+
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo),
   );
 
-  const interestAdaAmt = match(cdpDatum.cdpFees)
+  const interestAmt = match(cdpDatum.cdpFees)
     .with({ FrozenCDPAccumulatedFees: P.any }, () => {
       throw new Error('CDP fees wrong');
     })
     .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
-      const interestPaymentIAssetAmt = calculateAccruedInterest(
+      return calculateAccruedInterest(
         currentTime,
         interest.unitaryInterestSnapshot,
         cdpDatum.mintedAmt,
         interest.lastSettled,
         interestOracleDatum,
       );
-
-      const maxInterestLovelaces = computeInterestLovelacesFor100PercentCR(
-        lovelacesAmt(cdpUtxo.assets),
-        cdpDatum.mintedAmt,
-        priceOracleDatum.price,
-      );
-
-      return bigintMin(
-        maxInterestLovelaces,
-        ocdMul(
-          { getOnChainInt: interestPaymentIAssetAmt },
-          priceOracleDatum.price,
-        ).getOnChainInt,
-      );
     })
     .exhaustive();
 
-  const interestCollectorAdaAmt = calculateFeeFromPercentage(
-    iassetDatum.interestCollectorPortionPercentage,
-    interestAdaAmt,
+  const inputCollateral = assetClassValueOf(
+    cdpUtxo.assets,
+    cdpDatum.collateralAsset,
   );
 
-  const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
-
-  const inputCollateralMinusInterest =
-    lovelacesAmt(cdpUtxo.assets) - interestAdaAmt;
-
-  const cdpDebtAdaValue = ocdMul(
-    { getOnChainInt: cdpDatum.mintedAmt },
-    priceOracleDatum.price,
-  ).getOnChainInt;
+  const cdpDebtCollateralValue = rationalFloor(
+    rationalMul(
+      rationalFromInt(cdpDatum.mintedAmt + interestAmt),
+      adjustedPrice,
+    ),
+  );
 
   const liquidationProcessingFee = bigintMin(
-    calculateFeeFromPercentage(
-      iassetDatum.liquidationProcessingFeePercentage,
-      inputCollateralMinusInterest,
-    ),
-    calculateFeeFromPercentage(
-      iassetDatum.liquidationProcessingFeePercentage,
-      cdpDebtAdaValue,
+    calculateFeeFromRatio(
+      iassetDatum.liquidationProcessingFeeRatio,
+      inputCollateral,
     ),
+    bigintMax(0n, inputCollateral - cdpDebtCollateralValue),
   );
 
-  const txValidity = oracleExpirationAwareValidity(
+  let referenceInputs = [iassetUtxo, collateralAssetUtxo, interestOracleUtxo];
+  const referenceScripts = [cdpRefScriptUtxo];
+
+  const tx = lucid.newTx();
+
+  const { interval, referenceInputs: oracleRefInputs } = await attachOracle(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    priceOracleOref,
+    pythStateOref,
+    pythMessage,
+    sysParams.pythConfig,
+    sysParams.cdpParams.biasTime,
     currentSlot,
-    Number(sysParams.cdpCreatorParams.biasTime),
-    Number(priceOracleDatum.expiration),
-    network,
-  );
-
-  return (
-    lucid
-      .newTx()
-      // Ref Script
-      .readFrom([cdpRefScriptUtxo])
-      // Ref inputs
-      .readFrom([iassetUtxo, priceOracleUtxo, interestOracleUtxo])
-      .validFrom(txValidity.validFrom)
-      .validTo(txValidity.validTo)
-      .collectFrom(
-        [cdpUtxo],
-        serialiseCdpRedeemer({ FreezeCdp: { currentTime: currentTime } }),
-      )
-      .pay.ToContract(
-        createScriptAddress(network, sysParams.validatorHashes.cdpHash),
-        {
-          kind: 'inline',
-          value: serialiseCdpDatum({
-            ...cdpDatum,
-            cdpOwner: null,
-            cdpFees: {
-              FrozenCDPAccumulatedFees: {
-                lovelacesIndyStakers:
-                  liquidationProcessingFee + interestCollectorAdaAmt,
-                lovelacesTreasury: interestTreasuryAdaAmt,
-              },
-            },
-          }),
-        },
-        cdpUtxo.assets,
-      )
+    lucid,
+    tx,
   );
+
+  referenceInputs = [...oracleRefInputs, ...referenceInputs];
+
+  const refInputsIndices = getInputIndices(referenceInputs, [
+    ...referenceInputs,
+    ...referenceScripts,
+  ]);
+
+  return tx
+    .readFrom(referenceScripts)
+    .readFrom(referenceInputs)
+    .validFrom(interval.validFrom)
+    .validTo(interval.validTo)
+    .collectFrom(
+      [cdpUtxo],
+      serialiseCdpRedeemer({
+        FreezeCdp: {
+          currentTime: currentTime,
+          priceOracleIdx: { OracleRefInputIdx: refInputsIndices[0] },
+        },
+      }),
+    )
+    .pay.ToContract(
+      createScriptAddress(network, sysParams.validatorHashes.cdpHash),
+      {
+        kind: 'inline',
+        value: serialiseCdpDatum({
+          ...cdpDatum,
+          cdpOwner: null,
+          cdpFees: {
+            FrozenCDPAccumulatedFees: {
+              iassetInterest: interestAmt,
+              collateralTreasury: liquidationProcessingFee,
+            },
+          },
+        }),
+      },
+      cdpUtxo.assets,
+    );
 }
 
 export async function liquidateCdp(
-  cdp: UtxoOrOutRef,
-  stabilityPool: UtxoOrOutRef,
-  collector: UtxoOrOutRef,
-  treasury: UtxoOrOutRef,
+  cdpOref: OutRef,
+  stabilityPoolOref: OutRef,
+  interestCollectorOref: OutRef,
+  treasuryOref: OutRef,
   sysParams: SystemParams,
   lucid: LucidEvolution,
 ): Promise<TxBuilder> {
@@ -1081,21 +1325,23 @@ export async function liquidateCdp(
     (_) => new Error('Expected a single cdp auth token policy Ref Script UTXO'),
   );
 
-  const cdpUtxo = await resolveUtxo(cdp, lucid, 'Expected a single cdp UTXO');
+  const cdpUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpOref]),
+    (_) => new Error('Expected a single cdp UTXO'),
+  );
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
 
-  const spUtxo = await resolveUtxo(
-    stabilityPool,
-    lucid,
-    'Expected a single stability pool UTXO',
+  const spUtxo = matchSingle(
+    await lucid.utxosByOutRef([stabilityPoolOref]),
+    (_) => new Error('Expected a single stability pool UTXO'),
   );
-  const spDatum = parseStabilityPoolDatum(getInlineDatumOrThrow(spUtxo));
+  const spDatum = parseStabilityPoolDatumOrThrow(getInlineDatumOrThrow(spUtxo));
 
-  const [lovelacesForTreasury, lovelacesForCollector] = match(cdpDatum.cdpFees)
+  const [frozenInterest, collateralForTreasury] = match(cdpDatum.cdpFees)
     .returnType<[bigint, bigint]>()
     .with({ FrozenCDPAccumulatedFees: P.select() }, (fees) => [
-      fees.lovelacesTreasury,
-      fees.lovelacesIndyStakers,
+      fees.iassetInterest,
+      fees.collateralTreasury,
     ])
     .with({ ActiveCDPInterestTracking: P.any }, () => {
       throw new Error('CDP fees wrong');
@@ -1104,21 +1350,36 @@ export async function liquidateCdp(
 
   const cdpNftAc = fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken);
   const iassetsAc = {
-    currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+    currencySymbol: fromHex(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+    ),
     tokenName: cdpDatum.iasset,
   };
 
   const spIassetAmt = assetClassValueOf(spUtxo.assets, iassetsAc);
 
-  const iassetBurnAmt = bigintMin(cdpDatum.mintedAmt, spIassetAmt);
+  const totalCdpDebt = cdpDatum.mintedAmt + frozenInterest;
+
+  // Take from the SP enough as much iAsset as possible to pay out the debt.
+  const iassetUsedAmt = bigintMin(totalCdpDebt, spIassetAmt);
 
-  const collateralAvailable = lovelacesAmt(cdpUtxo.assets);
-  const collateralAvailMinusFees =
-    collateralAvailable - lovelacesForCollector - lovelacesForTreasury;
+  const collateralAvailable = assetClassValueOf(
+    cdpUtxo.assets,
+    cdpDatum.collateralAsset,
+  );
+  const collateralAvailMinusFees = collateralAvailable - collateralForTreasury;
   const collateralAbsorbed =
-    (collateralAvailMinusFees * iassetBurnAmt) / cdpDatum.mintedAmt;
+    (collateralAvailMinusFees * iassetUsedAmt) / totalCdpDebt;
+
+  const isPartial = spIassetAmt < totalCdpDebt;
+
+  // Interest partially paid if the liquidity in the SP is not enough to cover it.
+  const remainingInterest = bigintMax(frozenInterest - spIassetAmt, 0n);
+
+  const payableInterest = frozenInterest - remainingInterest;
 
-  const isPartial = spIassetAmt < cdpDatum.mintedAmt;
+  // All the iAsset taken from the SP and not used to pay out the interest must be burnt.
+  const iassetBurnAmt = iassetUsedAmt - payableInterest;
 
   const tx = lucid
     .newTx()
@@ -1138,18 +1399,32 @@ export async function liquidateCdp(
         value: serialiseStabilityPoolDatum({
           StabilityPool: liquidationHelper(
             spDatum,
-            iassetBurnAmt,
+            cdpDatum.collateralAsset,
+            iassetUsedAmt,
             collateralAbsorbed,
-          ).newSpContent,
+          ),
         }),
       },
       addAssets(
         spUtxo.assets,
-        mkLovelacesOf(collateralAbsorbed),
-        mkAssetsOf(iassetsAc, -iassetBurnAmt),
+        mkAssetsOf(cdpDatum.collateralAsset, collateralAbsorbed),
+        mkAssetsOf(iassetsAc, -iassetUsedAmt),
       ),
     );
 
+  if (collateralForTreasury > 0n) {
+    await treasuryFeeTx(
+      cdpDatum.collateralAsset,
+      collateralForTreasury,
+      0n,
+      lucid,
+      sysParams,
+      tx,
+      cdpOref,
+      treasuryOref,
+    );
+  }
+
   if (isPartial) {
     tx.pay.ToContract(
       cdpUtxo.address,
@@ -1157,18 +1432,23 @@ export async function liquidateCdp(
         kind: 'inline',
         value: serialiseCdpDatum({
           ...cdpDatum,
-          mintedAmt: cdpDatum.mintedAmt - spIassetAmt,
+          mintedAmt: cdpDatum.mintedAmt - iassetBurnAmt,
           cdpFees: {
             FrozenCDPAccumulatedFees: {
-              lovelacesIndyStakers: 0n,
-              lovelacesTreasury: 0n,
+              iassetInterest: remainingInterest,
+              collateralTreasury: 0n,
             },
           },
         }),
       },
       addAssets(
-        mkAssetsOf(cdpNftAc, assetClassValueOf(cdpUtxo.assets, cdpNftAc)),
-        mkLovelacesOf(collateralAvailable - collateralAbsorbed),
+        cdpUtxo.assets,
+        negateAssets(
+          mkAssetsOf(
+            cdpDatum.collateralAsset,
+            collateralForTreasury + collateralAbsorbed,
+          ),
+        ),
       ),
     );
   } else {
@@ -1178,9 +1458,15 @@ export async function liquidateCdp(
     );
   }
 
-  await collectorFeeTx(lovelacesForCollector, lucid, sysParams, tx, collector);
-
-  await treasuryFeeTx(lovelacesForTreasury, lucid, sysParams, tx, treasury);
+  if (payableInterest > 0) {
+    await collectInterestTx(
+      mkAssetsOf(iassetsAc, payableInterest),
+      lucid,
+      sysParams,
+      tx,
+      interestCollectorOref,
+    );
+  }
 
   return tx;
 }
@@ -1217,22 +1503,21 @@ export async function mergeCdps(
   );
 
   type AggregatedFees = {
-    aggregatedFeeIndyStakers: bigint;
-    aggregatedFeeTreasury: bigint;
+    aggregatedCollateralTreasury: bigint;
+    aggregatedInterest: bigint;
   };
 
-  const { aggregatedFeeTreasury, aggregatedFeeIndyStakers } = F.pipe(
+  const { aggregatedInterest, aggregatedCollateralTreasury } = F.pipe(
     cdpDatums,
     A.reduce<CDPContent, AggregatedFees>(
-      { aggregatedFeeIndyStakers: 0n, aggregatedFeeTreasury: 0n },
+      { aggregatedCollateralTreasury: 0n, aggregatedInterest: 0n },
       (acc, cdpDat) =>
         match(cdpDat.cdpFees)
           .returnType<AggregatedFees>()
           .with({ FrozenCDPAccumulatedFees: P.select() }, (fees) => ({
-            aggregatedFeeIndyStakers:
-              acc.aggregatedFeeIndyStakers + fees.lovelacesIndyStakers,
-            aggregatedFeeTreasury:
-              acc.aggregatedFeeTreasury + fees.lovelacesTreasury,
+            aggregatedCollateralTreasury:
+              acc.aggregatedCollateralTreasury + fees.collateralTreasury,
+            aggregatedInterest: acc.aggregatedInterest + fees.iassetInterest,
           }))
           .otherwise(() => acc),
     ),
@@ -1260,7 +1545,7 @@ export async function mergeCdps(
         MergeAuxiliary: {
           mainMergeUtxo: {
             outputIndex: BigInt(mainMergeUtxo.outputIndex),
-            txHash: { hash: mainMergeUtxo.txHash },
+            txHash: fromHex(mainMergeUtxo.txHash),
           },
         },
       }),
@@ -1272,11 +1557,12 @@ export async function mergeCdps(
         value: serialiseCdpDatum({
           cdpOwner: null,
           iasset: mainCdpDatum.iasset,
+          collateralAsset: mainCdpDatum.collateralAsset,
           mintedAmt: aggregatedMintedAmt,
           cdpFees: {
             FrozenCDPAccumulatedFees: {
-              lovelacesIndyStakers: aggregatedFeeIndyStakers,
-              lovelacesTreasury: aggregatedFeeTreasury,
+              collateralTreasury: aggregatedCollateralTreasury,
+              iassetInterest: aggregatedInterest,
             },
           },
         }),