@indigo-labs/indigo-sdk 0.1.0

package/src/contracts/cdp.ts

@@ -0,0 +1,892 @@
+import {
+  applyParamsToScript,
+  Assets,
+  Constr,
+  Credential,
+  Data,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  SpendingValidator,
+  toText,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  CdpParams,
+  ScriptReferences,
+  SystemParams,
+} from '../types/system-params';
+import { IAssetHelpers } from '../helpers/asset-helpers';
+import { PriceOracleContract } from './price-oracle';
+import { CDPCreatorContract } from './cdp-creator';
+import { CollectorContract } from './collector';
+import { InterestOracleContract } from './interest-oracle';
+import { GovContract } from './gov';
+import { TreasuryContract } from './treasury';
+import { addrDetails, getRandomElement, scriptRef } from '../helpers/lucid-utils';
+import { AssetClass } from '../types/generic';
+import { calculateFeeFromPercentage } from '../helpers/helpers';
+import { CDP, CDPDatum, CDPFees } from '../types/indigo/cdp';
+import { _cdpValidator } from '../scripts/cdp-validator';
+
+export class CDPContract {
+  static async openPosition(
+    asset: string,
+    collateralAmount: bigint,
+    mintedAmount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    cdpCreatorRef?: OutRef,
+    collectorRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const [pkh, skh] = await addrDetails(lucid);
+    const now = Date.now();
+    const assetOut = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, params, lucid)
+      : IAssetHelpers.findIAssetByName(asset, params, lucid));
+
+    // Fail if delisted asset
+    if ('getOnChainPrice' in assetOut.datum.price)
+      return Promise.reject('Trying to open CDP against delisted asset');
+
+    const oracleAsset = assetOut.datum.price as AssetClass;
+    const oracleOut = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset[0].unCurrencySymbol +
+            fromText(oracleAsset[1].unTokenName),
+        );
+    if (!oracleOut.datum) return Promise.reject('Price Oracle datum not found');
+    const oracleDatum = PriceOracleContract.decodePriceOracleDatum(
+      oracleOut.datum,
+    );
+
+    const interestOracleAsset = assetOut.datum.interestOracle;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset[0].unCurrencySymbol +
+            fromText(interestOracleAsset[1].unTokenName),
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject('Interest Oracle datum not found');
+    const interestOracleDatum =
+      InterestOracleContract.decodeInterestOracleDatum(interestOracleOut.datum);
+
+    const cdpCreatorOut = getRandomElement(
+      cdpCreatorRef
+        ? await lucid.utxosByOutRef([cdpCreatorRef])
+        : await lucid.utxosAtWithUnit(
+            CDPCreatorContract.address(params.cdpCreatorParams, lucid),
+            params.cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol +
+              fromText(params.cdpCreatorParams.cdpCreatorNft[1].unTokenName),
+          ),
+    );
+    const cdpCreatorRedeemer = CDPCreatorContract.redeemer(
+      pkh,
+      mintedAmount,
+      collateralAmount,
+      BigInt(now),
+    );
+    const cdpCreatorScriptRefUtxo = await CDPCreatorContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    const cdpAddress = CDPContract.address(params.cdpParams, lucid, skh);
+    const cdpToken =
+      params.cdpParams.cdpAuthToken[0].unCurrencySymbol +
+      fromText(params.cdpParams.cdpAuthToken[1].unTokenName);
+
+    const cdpValue: Assets = {
+      lovelace: collateralAmount,
+    };
+    cdpValue[cdpToken] = 1n;
+    const newSnapshot = InterestOracleContract.calculateUnitaryInterestSinceOracleLastUpdated(
+      BigInt(now),
+      interestOracleDatum,
+    ) + interestOracleDatum.unitaryInterest;
+    const cdpDatum = CDPContract.datum(pkh, asset, mintedAmount, {
+      type: 'ActiveCDPInterestTracking',
+      last_settled: BigInt(now),
+      unitary_interest_snapshot: newSnapshot
+    });
+    
+    const assetToken =
+      params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(asset);
+    const cdpTokenMintValue: Assets = {};
+    cdpTokenMintValue[cdpToken] = 1n;
+    const iassetTokenMintValue: Assets = {};
+    iassetTokenMintValue[assetToken] = BigInt(mintedAmount);
+
+    const cdpAuthTokenScriptRefUtxo = await CDPContract.cdpAuthTokenRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const iAssetTokenScriptRefUtxo = await CDPContract.assetTokenRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    const debtMintingFee = calculateFeeFromPercentage(
+      BigInt(assetOut.datum.debtMintingFeePercentage.getOnChainInt),
+      mintedAmount * oracleDatum.price,
+    );
+
+    // Oracle timestamp - 20s (length of a slot)
+    const cappedValidateTo = oracleDatum.expiration - 20_001n;
+    const timeValidFrom = now - 1_000;
+    const timeValidTo_ = now + params.cdpCreatorParams.biasTime - 1_000;
+    const timeValidTo =
+      cappedValidateTo <= timeValidFrom
+        ? timeValidTo_
+        : Math.min(timeValidTo_, Number(cappedValidateTo));
+
+    const tx = lucid
+      .newTx()
+      .collectFrom([cdpCreatorOut], Data.to(cdpCreatorRedeemer))
+      .readFrom([cdpCreatorScriptRefUtxo])
+      .pay.ToContract(
+        cdpAddress,
+        { kind: 'inline', value: Data.to(cdpDatum) },
+        cdpValue,
+      )
+      .pay.ToContract(
+        cdpCreatorOut.address,
+        { kind: 'inline', value: cdpCreatorOut.datum },
+        cdpCreatorOut.assets,
+      )
+      .readFrom([oracleOut, interestOracleOut, assetOut.utxo])
+      .mintAssets(cdpTokenMintValue, Data.to(new Constr(0, [])))
+      .readFrom([cdpAuthTokenScriptRefUtxo])
+      .mintAssets(iassetTokenMintValue, Data.to(new Constr(0, [])))
+      .readFrom([iAssetTokenScriptRefUtxo])
+      .addSignerKey(pkh.hash)
+      .validFrom(Number(now - 60_000))
+      .validTo(Number(timeValidTo));
+
+      if (debtMintingFee > 0) {
+        await CollectorContract.feeTx(
+          debtMintingFee,
+          lucid,
+          params,
+          tx,
+          collectorRef,
+        );
+      }
+    return tx;
+  }
+
+  static async deposit(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      amount,
+      0n,
+      params,
+      lucid,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async withdraw(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      -amount,
+      0n,
+      params,
+      lucid,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async mint(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      0n,
+      amount,
+      params,
+      lucid,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async burn(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      0n,
+      -amount,
+      params,
+      lucid,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async adjust(
+    cdpRef: OutRef,
+    collateralAmount: bigint,
+    mintAmount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    // Find Pkh, Skh
+    const [pkh, skh] = await addrDetails(lucid);
+    const now = Date.now();
+
+    // Fail if no pkh
+    if (!pkh)
+      return Promise.reject(
+        'Unable to determine the pub key hash of the wallet',
+      );
+
+    // Find Outputs: iAsset Output, CDP Output, Gov Output
+    const cdp = (await lucid.utxosByOutRef([cdpRef]))[0];
+    if (!cdp.datum) throw 'Unable to find CDP Datum';
+    const cdpDatum = CDPContract.decodeCdpDatum(cdp.datum);
+    if (cdpDatum.type !== 'CDP') throw 'Invalid CDP Datum';
+    const iAsset = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, params, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.asset, params, lucid));
+
+    const gov = govRef
+      ? (await lucid.utxosByOutRef([govRef]))[0]
+      : await lucid.utxoByUnit(
+          params.govParams.govNFT[0].unCurrencySymbol +
+            fromText(params.govParams.govNFT[1].unTokenName),
+        );
+    // const [iAsset, cdp, gov] = await lucid.utxosByOutRef([
+    //   dIAssetTokenRef,
+    //   dCDPTokenRef,
+    //   dGovTokenRef,
+    // ]);
+    if (!gov.datum) throw 'Unable to find Gov Datum';
+    const govData = GovContract.decodeGovDatum(gov.datum);
+    if (!govData) throw 'No Governance datum found';
+    const cdpScriptRefUtxo = await CDPContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const cdpAssets = Object.assign({}, cdp.assets);
+    cdpAssets['lovelace'] = cdp.assets['lovelace'] + collateralAmount;
+
+    const interestOracleAsset = iAsset.datum.interestOracle;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset[0].unCurrencySymbol +
+            fromText(interestOracleAsset[1].unTokenName),
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject('Interest Oracle datum not found');
+    const interestOracleDatum =
+      InterestOracleContract.decodeInterestOracleDatum(interestOracleOut.datum);
+
+    let tx = lucid
+      .newTx()
+      .collectFrom([cdp], Data.to(new Constr(0, [BigInt(now), mintAmount, collateralAmount])))
+      .readFrom([iAsset.utxo, gov, cdpScriptRefUtxo])
+      .addSignerKey(pkh.hash);
+    if (!cdp.datum) throw 'Unable to find CDP Datum';
+    let cdpD = CDPContract.decodeCdpDatum(cdp.datum);
+    if (!cdpD || cdpD.type !== 'CDP') throw 'Invalid CDP Datum';
+
+    if (cdpD.fees.type !== 'ActiveCDPInterestTracking')
+      throw 'Invalid CDP Fees';
+    
+    const newSnapshot = InterestOracleContract.calculateUnitaryInterestSinceOracleLastUpdated(
+      BigInt(now),
+      interestOracleDatum,
+    ) + interestOracleDatum.unitaryInterest;
+    
+    const cdpD_: CDP = { 
+      ...cdpD, 
+      mintedAmount: cdpD.mintedAmount + mintAmount, 
+      fees: { 
+        type: 'ActiveCDPInterestTracking', 
+        last_settled: BigInt(now), 
+        unitary_interest_snapshot: newSnapshot
+      } 
+    };
+
+    tx.pay.ToContract(
+      cdp.address,
+      {
+        kind: 'inline',
+        value: CDPContract.encodeCdpDatum(cdpD_),
+      },
+      cdpAssets,
+    );
+
+    // Find Oracle Ref Input
+    const oracleAsset = iAsset.datum.price as AssetClass;
+    const oracleRefInput = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset[0].unCurrencySymbol +
+            fromText(oracleAsset[1].unTokenName),
+        );
+
+    // Fail if delisted asset
+    if (!oracleRefInput.datum) return Promise.reject('Invalid oracle input');
+    const od = PriceOracleContract.decodePriceOracleDatum(oracleRefInput.datum);
+    if (!od) return Promise.reject('Invalid oracle input');
+
+    // TODO: Sanity check: oacle expiration
+    // Oracle timestamp - 20s (length of a slot)
+    // Oracle timestamp - 20s (length of a slot)
+    const cappedValidateTo = od.expiration - 20_001n;
+    const timeValidFrom = now - 1_000;
+    const timeValidTo_ = now + params.cdpCreatorParams.biasTime - 1_000;
+    const timeValidTo =
+      cappedValidateTo <= timeValidFrom
+        ? timeValidTo_
+        : Math.min(timeValidTo_, Number(cappedValidateTo));
+    tx
+      .readFrom([oracleRefInput])
+      .validFrom(Number(timeValidFrom))
+      .validTo(Number(timeValidTo));
+
+    let fee = 0n;
+    if (collateralAmount < 0) {
+      fee += calculateFeeFromPercentage(
+        govData.protocolParams.collateralFeePercentage,
+        collateralAmount,
+      );
+    }
+
+    if (mintAmount > 0) {
+      fee += calculateFeeFromPercentage(
+        iAsset.datum.debtMintingFeePercentage.getOnChainInt,
+        mintAmount * od.price,
+      );
+    }
+
+    // Interest payment
+    
+    const interestPaymentAsset = InterestOracleContract.calculateAccruedInterest(
+      BigInt(now),
+      cdpD.fees.unitary_interest_snapshot,
+      cdpD.mintedAmount,
+      cdpD.fees.last_settled,
+      interestOracleDatum,
+    );
+    const interestPayment = (interestPaymentAsset * od.price) / 1_000_000n;
+    const interestCollectorPayment = calculateFeeFromPercentage(
+      iAsset.datum.interestCollectorPortionPercentage.getOnChainInt,
+      interestPayment,
+    );
+    const interestTreasuryPayment = interestPayment - interestCollectorPayment;
+    console.log(interestPayment, interestCollectorPayment, interestTreasuryPayment);
+    if (interestTreasuryPayment > 0) {
+      await TreasuryContract.feeTx(interestTreasuryPayment, lucid, params, tx, treasuryRef);
+    }
+
+    fee += interestCollectorPayment;
+    tx.readFrom([interestOracleOut]);
+
+    if (mintAmount !== 0n) {
+      const iAssetTokenScriptRefUtxo = await CDPContract.assetTokenRef(
+        params.scriptReferences,
+        lucid,
+      );
+      const iassetToken =
+        params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(cdpD.asset);
+      const mintValue = {} as Assets;
+      mintValue[iassetToken] = mintAmount;
+
+      tx.readFrom([iAssetTokenScriptRefUtxo]).mintAssets(
+        mintValue,
+        Data.to(new Constr(0, [])),
+      );
+    }
+
+    if (fee > 0n) {
+      await CollectorContract.feeTx(fee, lucid, params, tx, collectorRef)
+    }
+
+    return tx;
+  }
+
+  static async close(
+    cdpRef: OutRef,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    // Find Pkh, Skh
+    const [pkh, skh] = await addrDetails(lucid);
+    const now = Date.now();
+
+    // Fail if no pkh
+    if (!pkh)
+      return Promise.reject(
+        'Unable to determine the pub key hash of the wallet',
+      );
+
+    // Find Outputs: iAsset Output, CDP Output, Gov Output
+    const cdp = (await lucid.utxosByOutRef([cdpRef]))[0];
+    if (!cdp.datum) throw 'Unable to find CDP Datum';
+    const cdpDatum = CDPContract.decodeCdpDatum(cdp.datum);
+    if (cdpDatum.type !== 'CDP') throw 'Invalid CDP Datum';
+    const iAsset = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, params, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.asset, params, lucid));
+
+    const gov = govRef
+      ? (await lucid.utxosByOutRef([govRef]))[0]
+      : await lucid.utxoByUnit(
+          params.govParams.govNFT[0].unCurrencySymbol +
+            fromText(params.govParams.govNFT[1].unTokenName),
+        );
+        
+    if (!gov.datum) throw 'Unable to find Gov Datum';
+    const govData = GovContract.decodeGovDatum(gov.datum);
+    if (!govData) throw 'No Governance datum found';
+    const cdpScriptRefUtxo = await CDPContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    const interestOracleAsset = iAsset.datum.interestOracle;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset[0].unCurrencySymbol +
+            fromText(interestOracleAsset[1].unTokenName),
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject('Interest Oracle datum not found');
+    const interestOracleDatum =
+      InterestOracleContract.decodeInterestOracleDatum(interestOracleOut.datum);
+
+    let tx = lucid
+      .newTx()
+      .collectFrom([cdp], Data.to(new Constr(1, [BigInt(now)])))
+      .readFrom([iAsset.utxo, gov, cdpScriptRefUtxo])
+      .addSignerKey(pkh.hash);
+    if (!cdp.datum) throw 'Unable to find CDP Datum';
+    let cdpD = CDPContract.decodeCdpDatum(cdp.datum);
+    if (!cdpD || cdpD.type !== 'CDP') throw 'Invalid CDP Datum';
+
+    if (cdpD.fees.type !== 'ActiveCDPInterestTracking')
+      throw 'Invalid CDP Fees';
+
+    // Find Oracle Ref Input
+    const oracleAsset = iAsset.datum.price as AssetClass;
+    const oracleRefInput = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset[0].unCurrencySymbol +
+            fromText(oracleAsset[1].unTokenName),
+        );
+
+    // Fail if delisted asset
+    if (!oracleRefInput.datum) return Promise.reject('Invalid oracle input');
+    const od = PriceOracleContract.decodePriceOracleDatum(oracleRefInput.datum);
+    if (!od) return Promise.reject('Invalid oracle input');
+
+    // TODO: Sanity check: oacle expiration
+    // Oracle timestamp - 20s (length of a slot)
+    // Oracle timestamp - 20s (length of a slot)
+    const cappedValidateTo = od.expiration - 20_001n;
+    const timeValidFrom = now - 1_000;
+    const timeValidTo_ = now + params.cdpCreatorParams.biasTime - 1_000;
+    const timeValidTo =
+      cappedValidateTo <= timeValidFrom
+        ? timeValidTo_
+        : Math.min(timeValidTo_, Number(cappedValidateTo));
+    tx
+      .readFrom([oracleRefInput])
+      .validFrom(Number(timeValidFrom))
+      .validTo(Number(timeValidTo));
+
+    let fee = 0n;
+
+    // Interest payment
+    const interestPaymentAsset = InterestOracleContract.calculateAccruedInterest(
+      BigInt(now),
+      cdpD.fees.unitary_interest_snapshot,
+      cdpD.mintedAmount,
+      cdpD.fees.last_settled,
+      interestOracleDatum,
+    );
+    const interestPayment = (interestPaymentAsset * od.price) / 1_000_000n;
+    const interestCollectorPayment = calculateFeeFromPercentage(
+      iAsset.datum.interestCollectorPortionPercentage.getOnChainInt,
+      interestPayment,
+    );
+    const interestTreasuryPayment = interestPayment - interestCollectorPayment;
+    console.log(interestPayment, interestCollectorPayment, interestTreasuryPayment);
+    if (interestTreasuryPayment > 0) {
+      await TreasuryContract.feeTx(interestTreasuryPayment, lucid, params, tx, treasuryRef);
+    }
+
+    fee += interestCollectorPayment;
+    tx.readFrom([interestOracleOut]);
+
+    const iAssetTokenScriptRefUtxo = await CDPContract.assetTokenRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const iassetToken =
+      params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(cdpD.asset);
+    const assetBurnValue = {} as Assets;
+    assetBurnValue[iassetToken] = -BigInt(cdpD.mintedAmount);
+    const cdpTokenBurnValue = {} as Assets;
+    cdpTokenBurnValue[params.cdpParams.cdpAuthToken[0].unCurrencySymbol + fromText(params.cdpParams.cdpAuthToken[1].unTokenName)] = -1n;
+    const cdpAuthTokenScriptRefUtxo = await CDPContract.cdpAuthTokenRef(
+      params.scriptReferences,
+      lucid,
+    );
+    tx.readFrom([iAssetTokenScriptRefUtxo]).mintAssets(
+      assetBurnValue,
+      Data.to(new Constr(0, [])),
+    ).readFrom([cdpAuthTokenScriptRefUtxo]).mintAssets(
+      cdpTokenBurnValue,
+      Data.to(new Constr(0, [])),
+    );
+
+    if (fee > 0n) {
+      await CollectorContract.feeTx(fee, lucid, params, tx, collectorRef)
+    }
+
+    return tx;
+  }
+
+  static decodeCdpDatum(datum: string): CDPDatum {
+    const cdpDatum = Data.from(datum) as any;
+    if (cdpDatum.index == 1 && cdpDatum.fields[0].index == 0) {
+      const iasset = cdpDatum.fields[0].fields;
+      return {
+        type: 'IAsset',
+        name: toText(iasset[0]),
+        price:
+          iasset[1].index === 0
+            ? { getOnChainInt: iasset[1].fields[0] }
+            : [
+                { unCurrencySymbol: iasset[1].fields[0].fields[0].fields[0] },
+                {
+                  unTokenName: toText(iasset[1].fields[0].fields[0].fields[1]),
+                },
+              ],
+        interestOracle: [
+          { unCurrencySymbol: iasset[2].fields[0] },
+          { unTokenName: toText(iasset[2].fields[1]) },
+        ],
+        redemptionRatioPercentage: { getOnChainInt: iasset[3].fields[0] },
+        maintenanceRatioPercentage: { getOnChainInt: iasset[4].fields[0] },
+        liquidationRatioPercentage: { getOnChainInt: iasset[5].fields[0] },
+        debtMintingFeePercentage: { getOnChainInt: iasset[6].fields[0] },
+        liquidationProcessingFeePercentage: {
+          getOnChainInt: iasset[7].fields[0],
+        },
+        stabilityPoolWithdrawalFeePercentage: {
+          getOnChainInt: iasset[8].fields[0],
+        },
+        redemptionReimbursementPercentage: {
+          getOnChainInt: iasset[9].fields[0],
+        },
+        redemptionProcessingFeePercentage: {
+          getOnChainInt: iasset[10].fields[0],
+        },
+        interestCollectorPortionPercentage: {
+          getOnChainInt: iasset[11].fields[0],
+        },
+        firstAsset: iasset[12].index === 1,
+        nextAsset:
+          iasset[13].index === 0 ? toText(iasset[13].fields[0]) : undefined,
+      };
+    } else if (cdpDatum.index == 0 && cdpDatum.fields[0].index == 0) {
+      const cdp = cdpDatum.fields[0].fields;
+      return {
+        type: 'CDP',
+        owner: cdp[0].fields[0],
+        asset: toText(cdp[1]),
+        mintedAmount: cdp[2],
+        fees:
+          cdp[3].index === 0
+            ? {
+                type: 'ActiveCDPInterestTracking',
+                last_settled: cdp[3].fields[0],
+                unitary_interest_snapshot: cdp[3].fields[1],
+              }
+            : {
+                type: 'FrozenCDPAccumulatedFees',
+                lovelaces_treasury: cdp[3].fields[0],
+                lovelaces_indy_stakers: cdp[3].fields[1],
+              },
+      };
+    }
+
+    throw 'Invalid CDP Datum provided';
+  }
+
+  static encodeCdpDatum(datum: CDPDatum): string {
+    if (datum.type === 'CDP') {
+      return Data.to(
+        new Constr(0, [
+          new Constr(0, [
+            datum.owner ? new Constr(0, [datum.owner]) : new Constr(1, []),
+            fromText(datum.asset),
+            BigInt(datum.mintedAmount),
+            datum.fees.type === 'ActiveCDPInterestTracking'
+              ? new Constr(0, [
+                  datum.fees.last_settled,
+                  datum.fees.unitary_interest_snapshot,
+                ])
+              : new Constr(1, [
+                  datum.fees.lovelaces_treasury,
+                  datum.fees.lovelaces_indy_stakers,
+                ]),
+          ]),
+        ]),
+      );
+    } else if (datum.type === 'IAsset') {
+      return Data.to(
+        new Constr(1, [
+          new Constr(0, [
+            fromText(datum.name),
+            'getOnChainInt' in datum.price
+              ? new Constr(0, [
+                  new Constr(0, [BigInt(datum.price.getOnChainInt)]),
+                ])
+              : new Constr(1, [
+                  new Constr(0, [
+                    new Constr(0, [
+                      datum.price[0].unCurrencySymbol,
+                      fromText(datum.price[1].unTokenName),
+                    ]),
+                  ]),
+                ]),
+            new Constr(0, [
+              datum.interestOracle[0].unCurrencySymbol,
+              fromText(datum.interestOracle[1].unTokenName),
+            ]),
+            new Constr(0, [
+              BigInt(datum.redemptionRatioPercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.maintenanceRatioPercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.liquidationRatioPercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.debtMintingFeePercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.liquidationProcessingFeePercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.stabilityPoolWithdrawalFeePercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.redemptionReimbursementPercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.redemptionProcessingFeePercentage.getOnChainInt),
+            ]),
+            new Constr(0, [
+              BigInt(datum.interestCollectorPortionPercentage.getOnChainInt),
+            ]),
+            datum.firstAsset ? new Constr(1, []) : new Constr(0, []),
+            datum.nextAsset
+              ? new Constr(0, [fromText(datum.nextAsset)])
+              : new Constr(1, []),
+          ]),
+        ]),
+      );
+    }
+
+    throw 'Invalid CDP Datum provided';
+  }
+
+  static datum(
+    hash: Credential,
+    asset: string,
+    mintedAmount: bigint,
+    fees: CDPFees,
+  ): Constr<Data> {
+    return new Constr(0, [
+      new Constr(0, [
+        new Constr(0, [hash.hash]),
+        fromText(asset),
+        BigInt(mintedAmount),
+        fees.type === 'ActiveCDPInterestTracking'
+          ? new Constr(0, [
+              BigInt(fees.last_settled),
+              BigInt(fees.unitary_interest_snapshot),
+            ])
+          : new Constr(0, [
+              BigInt(fees.lovelaces_treasury),
+              BigInt(fees.lovelaces_indy_stakers),
+            ]),
+      ]),
+    ]);
+  }
+
+  static validator(params: CdpParams): SpendingValidator {
+    return {
+      type: _cdpValidator.type,
+      script: applyParamsToScript(_cdpValidator.cborHex, [
+        new Constr(0, [
+          new Constr(0, [
+            params.cdpAuthToken[0].unCurrencySymbol,
+            fromText(params.cdpAuthToken[1].unTokenName),
+          ]),
+          params.cdpAssetSymbol.unCurrencySymbol,
+          new Constr(0, [
+            params.iAssetAuthToken[0].unCurrencySymbol,
+            fromText(params.iAssetAuthToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.stabilityPoolAuthToken[0].unCurrencySymbol,
+            fromText(params.stabilityPoolAuthToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.versionRecordToken[0].unCurrencySymbol,
+            fromText(params.versionRecordToken[1].unTokenName),
+          ]),
+          new Constr(0, [
+            params.upgradeToken[0].unCurrencySymbol,
+            fromText(params.upgradeToken[1].unTokenName),
+          ]),
+          params.collectorValHash,
+          params.spValHash,
+          new Constr(0, [
+            params.govNFT[0].unCurrencySymbol,
+            fromText(params.govNFT[1].unTokenName),
+          ]),
+          BigInt(params.minCollateralInLovelace),
+          BigInt(params.partialRedemptionExtraFeeLovelace),
+          BigInt(params.biasTime),
+          params.treasuryValHash,
+        ]),
+      ]),
+    };
+  }
+
+  static validatorHash(params: CdpParams): string {
+    return validatorToScriptHash(CDPContract.validator(params));
+  }
+
+  static address(
+    cdpParams: CdpParams,
+    lucid: LucidEvolution,
+    skh?: Credential,
+  ) {
+    const network = lucid.config().network;
+    if (!network) {
+      throw new Error('Network configuration is undefined');
+    }
+    return validatorToAddress(network, CDPContract.validator(cdpParams), skh);
+  }
+
+  static scriptRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.cdpValidatorRef, lucid);
+  }
+
+  static cdpAuthTokenRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.authTokenPolicies.cdpAuthTokenRef, lucid);
+  }
+
+  static assetTokenRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.iAssetTokenPolicyRef, lucid);
+  }
+
+  static assetAuthTokenRef(
+    params: ScriptReferences,
+    lucid: LucidEvolution,
+  ): Promise<UTxO> {
+    return scriptRef(params.authTokenPolicies.iAssetTokenRef, lucid);
+  }
+}