@indigo-labs/indigo-sdk 0.1.20 → 0.1.22

package/src/contracts/cdp.ts

@@ -0,0 +1,746 @@
+import {
+  applyParamsToScript,
+  Assets,
+  Constr,
+  Credential,
+  credentialToAddress,
+  Data,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  slotToUnixTime,
+  SpendingValidator,
+  TxBuilder,
+  UTxO,
+  validatorToAddress,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import {
+  CdpParams,
+  ScriptReferences,
+  SystemParams,
+} from '../types/system-params';
+import { IAssetHelpers, IAssetOutput } from '../helpers/asset-helpers';
+import { CollectorContract } from './collector';
+import { TreasuryContract } from './treasury';
+import { addrDetails, scriptRef } from '../helpers/lucid-utils';
+import {
+  calculateFeeFromPercentage,
+  getRandomElement,
+} from '../helpers/helpers';
+import {
+  CDPContent,
+  parseCDPDatum,
+  serialiseCDPDatum,
+} from '../types/indigo/cdp';
+import { _cdpValidator } from '../scripts/cdp-validator';
+import { parsePriceOracleDatum } from '../types/indigo/price-oracle';
+import { parseInterestOracleDatum } from '../types/indigo/interest-oracle';
+import { castCDPCreatorRedeemer } from '../types/indigo/cdp-creator';
+import { parseGovDatum } from '../types/indigo/gov';
+import {
+  calculateAccruedInterest,
+  calculateUnitaryInterestSinceOracleLastUpdated,
+} from '../helpers/interest-oracle';
+import { oracleExpirationAwareValidity } from '../helpers/price-oracle-helpers';
+
+export class CDPContract {
+  static async openPosition(
+    asset: string,
+    collateralAmount: bigint,
+    mintedAmount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    cdpCreatorRef?: OutRef,
+    collectorRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const network = lucid.config().network;
+    const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+    const [pkh, skh] = await addrDetails(lucid);
+    const assetOut: IAssetOutput = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, lucid)
+      : IAssetHelpers.findIAssetByName(asset, params, lucid));
+    if (!assetOut || !assetOut.datum) throw new Error('Unable to find IAsset');
+    // Fail if delisted asset
+    if ('Delisted' in assetOut.datum.price)
+      return Promise.reject(
+        new Error('Trying to open CDP against delisted asset'),
+      );
+
+    const oracleAsset = assetOut.datum.price.Oracle.oracleNft.asset;
+    const oracleOut = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset.currencySymbol + oracleAsset.tokenName,
+        );
+    if (!oracleOut.datum)
+      return Promise.reject(new Error('Price Oracle datum not found'));
+    const oracleDatum = parsePriceOracleDatum(oracleOut.datum);
+
+    const interestOracleAsset = assetOut.datum.interestOracleNft;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset.currencySymbol + interestOracleAsset.tokenName,
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject(new Error('Interest Oracle datum not found'));
+    const interestOracleDatum = parseInterestOracleDatum(
+      interestOracleOut.datum,
+    );
+
+    const cdpCreatorOut = getRandomElement(
+      cdpCreatorRef
+        ? await lucid.utxosByOutRef([cdpCreatorRef])
+        : await lucid.utxosAtWithUnit(
+            credentialToAddress(network, {
+              type: 'Script',
+              hash: params.validatorHashes.cdpCreatorHash,
+            }),
+            params.cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol +
+              fromText(params.cdpCreatorParams.cdpCreatorNft[1].unTokenName),
+          ),
+    );
+
+    const cdpCreatorRedeemer = castCDPCreatorRedeemer({
+      CreateCDP: {
+        cdpOwner: pkh.hash,
+        minted: mintedAmount,
+        collateral: collateralAmount,
+        currentTime: currentTime,
+      },
+    });
+
+    const cdpCreatorScriptRefUtxo = await scriptRef(
+      params.scriptReferences.cdpCreatorValidatorRef,
+      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 =
+      calculateUnitaryInterestSinceOracleLastUpdated(
+        currentTime,
+        interestOracleDatum,
+      ) + interestOracleDatum.unitaryInterest;
+    const cdpDatum: CDPContent = {
+      cdpOwner: pkh.hash,
+      iasset: fromText(asset),
+      mintedAmt: mintedAmount,
+      cdpFees: {
+        ActiveCDPInterestTracking: {
+          lastSettled: currentTime,
+          unitaryInterestSnapshot: 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.getOnChainInt) / 1_000_000n,
+    );
+
+    const txValidity = oracleExpirationAwareValidity(
+      currentSlot,
+      Number(params.cdpCreatorParams.biasTime),
+      Number(oracleDatum.expiration),
+      network,
+    );
+
+    const tx = lucid
+      .newTx()
+      .collectFrom([cdpCreatorOut], Data.to(cdpCreatorRedeemer))
+      .readFrom([cdpCreatorScriptRefUtxo])
+      .pay.ToContract(
+        cdpAddress,
+        { kind: 'inline', value: serialiseCDPDatum(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(txValidity.validFrom)
+      .validTo(txValidity.validTo);
+
+    if (debtMintingFee > 0) {
+      await CollectorContract.feeTx(
+        debtMintingFee,
+        lucid,
+        params,
+        tx,
+        collectorRef,
+      );
+    }
+    return tx;
+  }
+
+  static async deposit(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      amount,
+      0n,
+      params,
+      lucid,
+      currentSlot,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async withdraw(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      -amount,
+      0n,
+      params,
+      lucid,
+      currentSlot,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async mint(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      0n,
+      amount,
+      params,
+      lucid,
+      currentSlot,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async burn(
+    cdpRef: OutRef,
+    amount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    return CDPContract.adjust(
+      cdpRef,
+      0n,
+      -amount,
+      params,
+      lucid,
+      currentSlot,
+      assetRef,
+      priceOracleRef,
+      interestOracleRef,
+      collectorRef,
+      govRef,
+      treasuryRef,
+    );
+  }
+
+  static async adjust(
+    cdpRef: OutRef,
+    collateralAmount: bigint,
+    mintAmount: bigint,
+    params: SystemParams,
+    lucid: LucidEvolution,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const network = lucid.config().network;
+    // Find Pkh, Skh
+    const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+    // Find Outputs: iAsset Output, CDP Output, Gov Output
+    const cdp = (await lucid.utxosByOutRef([cdpRef]))[0];
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpDatum = parseCDPDatum(cdp.datum);
+    const iAsset = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.iasset, 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 new Error('Unable to find Gov Datum');
+    const govData = parseGovDatum(gov.datum);
+    const cdpScriptRefUtxo = await CDPContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+    const cdpAssets = Object.assign({}, cdp.assets);
+    cdpAssets['lovelace'] = cdp.assets['lovelace'] + collateralAmount;
+
+    const interestOracleAsset = iAsset.datum.interestOracleNft;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset.currencySymbol +
+            fromText(interestOracleAsset.tokenName),
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject(new Error('Interest Oracle datum not found'));
+    const interestOracleDatum = parseInterestOracleDatum(
+      interestOracleOut.datum,
+    );
+
+    const tx = lucid
+      .newTx()
+      .collectFrom(
+        [cdp],
+        Data.to(new Constr(0, [currentTime, mintAmount, collateralAmount])),
+      )
+      .readFrom([iAsset.utxo, gov, cdpScriptRefUtxo])
+      .addSignerKey(cdpDatum.cdpOwner);
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpD = parseCDPDatum(cdp.datum);
+
+    if (!('ActiveCDPInterestTracking' in cdpD.cdpFees))
+      throw new Error('Invalid CDP Fees');
+
+    const newSnapshot =
+      calculateUnitaryInterestSinceOracleLastUpdated(
+        currentTime,
+        interestOracleDatum,
+      ) + interestOracleDatum.unitaryInterest;
+
+    const cdpD_: CDPContent = {
+      ...cdpD,
+      mintedAmt: cdpD.mintedAmt + mintAmount,
+      cdpFees: {
+        ActiveCDPInterestTracking: {
+          lastSettled: currentTime,
+          unitaryInterestSnapshot: newSnapshot,
+        },
+      },
+    };
+
+    tx.pay.ToContract(
+      cdp.address,
+      {
+        kind: 'inline',
+        value: serialiseCDPDatum(cdpD_),
+      },
+      cdpAssets,
+    );
+
+    // Find Oracle Ref Input
+    const oracleAsset = iAsset.datum.price;
+    if (!('Oracle' in oracleAsset)) throw new Error('Invalid oracle asset');
+    const oracleRefInput = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset.Oracle.oracleNft.asset.currencySymbol +
+            fromText(oracleAsset.Oracle.oracleNft.asset.tokenName),
+        );
+
+    // Fail if delisted asset
+    if (!oracleRefInput.datum)
+      return Promise.reject(new Error('Invalid oracle input'));
+    const od = parsePriceOracleDatum(oracleRefInput.datum);
+    if (!od) return Promise.reject(new Error('Invalid oracle input'));
+
+    const txValidity = oracleExpirationAwareValidity(
+      currentSlot,
+      Number(params.cdpCreatorParams.biasTime),
+      Number(od.expiration),
+      network,
+    );
+    tx.readFrom([oracleRefInput])
+      .validFrom(txValidity.validFrom)
+      .validTo(txValidity.validTo);
+
+    let fee = 0n;
+    if (collateralAmount < 0) {
+      fee += calculateFeeFromPercentage(
+        govData.protocolParams.collateralFeePercentage.getOnChainInt,
+        collateralAmount,
+      );
+    }
+
+    if (mintAmount > 0) {
+      fee += calculateFeeFromPercentage(
+        iAsset.datum.debtMintingFeePercentage.getOnChainInt,
+        (mintAmount * od.price.getOnChainInt) / 1_000_000n,
+      );
+    }
+
+    // Interest payment
+
+    const interestPaymentAsset = calculateAccruedInterest(
+      currentTime,
+      cdpD.cdpFees.ActiveCDPInterestTracking.unitaryInterestSnapshot,
+      cdpD.mintedAmt,
+      cdpD.cdpFees.ActiveCDPInterestTracking.lastSettled,
+      interestOracleDatum,
+    );
+    const interestPayment =
+      (interestPaymentAsset * od.price.getOnChainInt) / 1_000_000n;
+    const interestCollectorPayment = calculateFeeFromPercentage(
+      iAsset.datum.interestCollectorPortionPercentage.getOnChainInt,
+      interestPayment,
+    );
+    const interestTreasuryPayment = interestPayment - interestCollectorPayment;
+
+    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 + cdpD.iasset;
+      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,
+    currentSlot: number,
+    assetRef?: OutRef,
+    priceOracleRef?: OutRef,
+    interestOracleRef?: OutRef,
+    collectorRef?: OutRef,
+    govRef?: OutRef,
+    treasuryRef?: OutRef,
+  ): Promise<TxBuilder> {
+    const network = lucid.config().network;
+    // Find Pkh, Skh
+    const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+    // Find Outputs: iAsset Output, CDP Output, Gov Output
+    const cdp = (await lucid.utxosByOutRef([cdpRef]))[0];
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpDatum = parseCDPDatum(cdp.datum);
+    const iAsset = await (assetRef
+      ? IAssetHelpers.findIAssetByRef(assetRef, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.iasset, 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 new Error('Unable to find Gov Datum');
+    const cdpScriptRefUtxo = await CDPContract.scriptRef(
+      params.scriptReferences,
+      lucid,
+    );
+
+    const interestOracleAsset = iAsset.datum.interestOracleNft;
+    const interestOracleOut = interestOracleRef
+      ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          interestOracleAsset.currencySymbol +
+            fromText(interestOracleAsset.tokenName),
+        );
+    if (!interestOracleOut.datum)
+      return Promise.reject(new Error('Interest Oracle datum not found'));
+    const interestOracleDatum = parseInterestOracleDatum(
+      interestOracleOut.datum,
+    );
+
+    const tx = lucid
+      .newTx()
+      .collectFrom([cdp], Data.to(new Constr(1, [currentTime])))
+      .readFrom([iAsset.utxo, gov, cdpScriptRefUtxo])
+      .addSignerKey(cdpDatum.cdpOwner);
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpD = parseCDPDatum(cdp.datum);
+    if (!('ActiveCDPInterestTracking' in cdpD.cdpFees))
+      throw new Error('Invalid CDP Fees');
+
+    // Find Oracle Ref Input
+    if (!('Oracle' in iAsset.datum.price))
+      throw new Error('iAsset is delisted');
+    const oracleAsset = iAsset.datum.price.Oracle.oracleNft.asset;
+    const oracleRefInput = priceOracleRef
+      ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
+      : await lucid.utxoByUnit(
+          oracleAsset.currencySymbol + fromText(oracleAsset.tokenName),
+        );
+
+    // Fail if delisted asset
+    if (!oracleRefInput.datum)
+      return Promise.reject(new Error('Invalid oracle input'));
+    const od = parsePriceOracleDatum(oracleRefInput.datum);
+
+    const txValidity = oracleExpirationAwareValidity(
+      currentSlot,
+      Number(params.cdpCreatorParams.biasTime),
+      Number(od.expiration),
+      network,
+    );
+    tx.readFrom([oracleRefInput])
+      .validFrom(txValidity.validFrom)
+      .validTo(txValidity.validTo);
+
+    let fee = 0n;
+
+    // Interest payment
+    const interestPaymentAsset = calculateAccruedInterest(
+      currentTime,
+      cdpD.cdpFees.ActiveCDPInterestTracking.unitaryInterestSnapshot,
+      cdpD.mintedAmt,
+      cdpD.cdpFees.ActiveCDPInterestTracking.lastSettled,
+      interestOracleDatum,
+    );
+    const interestPayment =
+      (interestPaymentAsset * od.price.getOnChainInt) / 1_000_000n;
+    const interestCollectorPayment = calculateFeeFromPercentage(
+      iAsset.datum.interestCollectorPortionPercentage.getOnChainInt,
+      interestPayment,
+    );
+    const interestTreasuryPayment = interestPayment - interestCollectorPayment;
+
+    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 + cdpD.iasset;
+    const assetBurnValue = {} as Assets;
+    assetBurnValue[iassetToken] = -BigInt(cdpD.mintedAmt);
+    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 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);
+  }
+}