@indigo-labs/indigo-sdk 0.1.2 → 0.1.3

package/src/contracts/cdp.ts

@@ -3,12 +3,12 @@ import {
   Assets,
   Constr,
   Credential,
+  credentialToAddress,
   Data,
   fromText,
   LucidEvolution,
   OutRef,
   SpendingValidator,
-  toText,
   TxBuilder,
   UTxO,
   validatorToAddress,
@@ -19,18 +19,28 @@ import {
   ScriptReferences,
   SystemParams,
 } from '../types/system-params';
-import { IAssetHelpers } from '../helpers/asset-helpers';
-import { PriceOracleContract } from './price-oracle';
-import { CDPCreatorContract } from './cdp-creator';
+import { IAssetHelpers, IAssetOutput } from '../helpers/asset-helpers';
 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 { 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';
 
 export class CDPContract {
   static async openPosition(
@@ -44,58 +54,65 @@ export class CDPContract {
     interestOracleRef?: OutRef,
     cdpCreatorRef?: OutRef,
     collectorRef?: OutRef,
+    now: number = Date.now(),
   ): Promise<TxBuilder> {
     const [pkh, skh] = await addrDetails(lucid);
-    const now = Date.now();
-    const assetOut = await (assetRef
-      ? IAssetHelpers.findIAssetByRef(assetRef, params, 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 ('getOnChainPrice' in assetOut.datum.price)
-      return Promise.reject('Trying to open CDP against 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 as AssetClass;
+    const oracleAsset = assetOut.datum.price.Oracle.oracleNft.asset;
     const oracleOut = priceOracleRef
       ? (await lucid.utxosByOutRef([priceOracleRef]))[0]
       : await lucid.utxoByUnit(
-          oracleAsset[0].unCurrencySymbol +
-            fromText(oracleAsset[1].unTokenName),
+          oracleAsset.currencySymbol + oracleAsset.tokenName,
         );
-    if (!oracleOut.datum) return Promise.reject('Price Oracle datum not found');
-    const oracleDatum = PriceOracleContract.decodePriceOracleDatum(
-      oracleOut.datum,
-    );
+    if (!oracleOut.datum)
+      return Promise.reject(new Error('Price Oracle datum not found'));
+    const oracleDatum = parsePriceOracleDatum(oracleOut.datum);
 
-    const interestOracleAsset = assetOut.datum.interestOracle;
+    const interestOracleAsset = assetOut.datum.interestOracleNft;
     const interestOracleOut = interestOracleRef
       ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
       : await lucid.utxoByUnit(
-          interestOracleAsset[0].unCurrencySymbol +
-            fromText(interestOracleAsset[1].unTokenName),
+          interestOracleAsset.currencySymbol + interestOracleAsset.tokenName,
         );
     if (!interestOracleOut.datum)
-      return Promise.reject('Interest Oracle datum not found');
-    const interestOracleDatum =
-      InterestOracleContract.decodeInterestOracleDatum(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(
-            CDPCreatorContract.address(params.cdpCreatorParams, lucid),
+            credentialToAddress(lucid.config().network, {
+              type: 'Script',
+              hash: params.validatorHashes.cdpCreatorHash,
+            }),
             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,
+
+    const cdpCreatorRedeemer = castCDPCreatorRedeemer({
+      CreateCDP: {
+        cdpOwner: pkh.hash,
+        minted: mintedAmount,
+        collateral: collateralAmount,
+        currentTime: BigInt(now),
+      },
+    });
+
+    const cdpCreatorScriptRefUtxo = await scriptRef(
+      params.scriptReferences.cdpCreatorValidatorRef,
       lucid,
     );
 
@@ -108,16 +125,23 @@ export class CDPContract {
       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 newSnapshot =
+      calculateUnitaryInterestSinceOracleLastUpdated(
+        BigInt(now),
+        interestOracleDatum,
+      ) + interestOracleDatum.unitaryInterest;
+    const cdpDatum: CDPContent = {
+      cdpOwner: pkh.hash,
+      iasset: fromText(asset),
+      mintedAmt: mintedAmount,
+      cdpFees: {
+        ActiveCDPInterestTracking: {
+          lastSettled: BigInt(now),
+          unitaryInterestSnapshot: newSnapshot,
+        },
+      },
+    };
+
     const assetToken =
       params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(asset);
     const cdpTokenMintValue: Assets = {};
@@ -136,13 +160,13 @@ export class CDPContract {
 
     const debtMintingFee = calculateFeeFromPercentage(
       BigInt(assetOut.datum.debtMintingFeePercentage.getOnChainInt),
-      (mintedAmount * oracleDatum.price) / 1_000_000n,
+      (mintedAmount * oracleDatum.price.getOnChainInt) / 1_000_000n,
     );
 
     // 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_ = now + Number(params.cdpCreatorParams.biasTime) - 1_000;
     const timeValidTo =
       cappedValidateTo <= timeValidFrom
         ? timeValidTo_
@@ -154,7 +178,7 @@ export class CDPContract {
       .readFrom([cdpCreatorScriptRefUtxo])
       .pay.ToContract(
         cdpAddress,
-        { kind: 'inline', value: Data.to(cdpDatum) },
+        { kind: 'inline', value: serialiseCDPDatum(cdpDatum) },
         cdpValue,
       )
       .pay.ToContract(
@@ -168,18 +192,18 @@ export class CDPContract {
       .mintAssets(iassetTokenMintValue, Data.to(new Constr(0, [])))
       .readFrom([iAssetTokenScriptRefUtxo])
       .addSignerKey(pkh.hash)
-      .validFrom(Number(now - 60_000))
+      .validFrom(Number(now - 100))
       .validTo(Number(timeValidTo));
 
-      if (debtMintingFee > 0) {
-        await CollectorContract.feeTx(
-          debtMintingFee,
-          lucid,
-          params,
-          tx,
-          collectorRef,
-        );
-      }
+    if (debtMintingFee > 0) {
+      await CollectorContract.feeTx(
+        debtMintingFee,
+        lucid,
+        params,
+        tx,
+        collectorRef,
+      );
+    }
     return tx;
   }
 
@@ -305,23 +329,16 @@ export class CDPContract {
     treasuryRef?: OutRef,
   ): Promise<TxBuilder> {
     // Find Pkh, Skh
-    const [pkh, skh] = await addrDetails(lucid);
+    const [pkh, _] = 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';
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpDatum = parseCDPDatum(cdp.datum);
     const iAsset = await (assetRef
-      ? IAssetHelpers.findIAssetByRef(assetRef, params, lucid)
-      : IAssetHelpers.findIAssetByName(cdpDatum.asset, params, lucid));
+      ? IAssetHelpers.findIAssetByRef(assetRef, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.iasset, params, lucid));
 
     const gov = govRef
       ? (await lucid.utxosByOutRef([govRef]))[0]
@@ -329,14 +346,8 @@ export class CDPContract {
           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';
+    if (!gov.datum) throw new Error('Unable to find Gov Datum');
+    const govData = parseGovDatum(gov.datum);
     const cdpScriptRefUtxo = await CDPContract.scriptRef(
       params.scriptReferences,
       lucid,
@@ -344,87 +355,93 @@ export class CDPContract {
     const cdpAssets = Object.assign({}, cdp.assets);
     cdpAssets['lovelace'] = cdp.assets['lovelace'] + collateralAmount;
 
-    const interestOracleAsset = iAsset.datum.interestOracle;
+    const interestOracleAsset = iAsset.datum.interestOracleNft;
     const interestOracleOut = interestOracleRef
       ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
       : await lucid.utxoByUnit(
-          interestOracleAsset[0].unCurrencySymbol +
-            fromText(interestOracleAsset[1].unTokenName),
+          interestOracleAsset.currencySymbol +
+            fromText(interestOracleAsset.tokenName),
         );
     if (!interestOracleOut.datum)
-      return Promise.reject('Interest Oracle datum not found');
-    const interestOracleDatum =
-      InterestOracleContract.decodeInterestOracleDatum(interestOracleOut.datum);
+      return Promise.reject(new Error('Interest Oracle datum not found'));
+    const interestOracleDatum = parseInterestOracleDatum(
+      interestOracleOut.datum,
+    );
 
-    let tx = lucid
+    const tx = lucid
       .newTx()
-      .collectFrom([cdp], Data.to(new Constr(0, [BigInt(now), mintAmount, collateralAmount])))
+      .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
-      } 
+    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(
+        BigInt(now),
+        interestOracleDatum,
+      ) + interestOracleDatum.unitaryInterest;
+
+    const cdpD_: CDPContent = {
+      ...cdpD,
+      mintedAmt: cdpD.mintedAmt + mintAmount,
+      cdpFees: {
+        ActiveCDPInterestTracking: {
+          lastSettled: BigInt(now),
+          unitaryInterestSnapshot: newSnapshot,
+        },
+      },
     };
 
     tx.pay.ToContract(
       cdp.address,
       {
         kind: 'inline',
-        value: CDPContract.encodeCdpDatum(cdpD_),
+        value: serialiseCDPDatum(cdpD_),
       },
       cdpAssets,
     );
 
     // Find Oracle Ref Input
-    const oracleAsset = iAsset.datum.price as AssetClass;
+    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[0].unCurrencySymbol +
-            fromText(oracleAsset[1].unTokenName),
+          oracleAsset.Oracle.oracleNft.asset.currencySymbol +
+            fromText(oracleAsset.Oracle.oracleNft.asset.tokenName),
         );
 
     // 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');
+    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'));
 
     // 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_ = now + Number(params.cdpCreatorParams.biasTime) - 1_000;
     const timeValidTo =
       cappedValidateTo <= timeValidFrom
         ? timeValidTo_
         : Math.min(timeValidTo_, Number(cappedValidateTo));
-    tx
-      .readFrom([oracleRefInput])
+    tx.readFrom([oracleRefInput])
       .validFrom(Number(timeValidFrom))
       .validTo(Number(timeValidTo));
 
     let fee = 0n;
     if (collateralAmount < 0) {
       fee += calculateFeeFromPercentage(
-        govData.protocolParams.collateralFeePercentage,
+        govData.protocolParams.collateralFeePercentage.getOnChainInt,
         collateralAmount,
       );
     }
@@ -432,28 +449,35 @@ export class CDPContract {
     if (mintAmount > 0) {
       fee += calculateFeeFromPercentage(
         iAsset.datum.debtMintingFeePercentage.getOnChainInt,
-        (mintAmount * od.price) / 1_000_000n,
+        (mintAmount * od.price.getOnChainInt) / 1_000_000n,
       );
     }
 
     // Interest payment
-    
-    const interestPaymentAsset = InterestOracleContract.calculateAccruedInterest(
+
+    const interestPaymentAsset = calculateAccruedInterest(
       BigInt(now),
-      cdpD.fees.unitary_interest_snapshot,
-      cdpD.mintedAmount,
-      cdpD.fees.last_settled,
+      cdpD.cdpFees.ActiveCDPInterestTracking.unitaryInterestSnapshot,
+      cdpD.mintedAmt,
+      cdpD.cdpFees.ActiveCDPInterestTracking.lastSettled,
       interestOracleDatum,
     );
-    const interestPayment = (interestPaymentAsset * od.price) / 1_000_000n;
+    const interestPayment =
+      (interestPaymentAsset * od.price.getOnChainInt) / 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);
+      await TreasuryContract.feeTx(
+        interestTreasuryPayment,
+        lucid,
+        params,
+        tx,
+        treasuryRef,
+      );
     }
 
     fee += interestCollectorPayment;
@@ -465,7 +489,7 @@ export class CDPContract {
         lucid,
       );
       const iassetToken =
-        params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(cdpD.asset);
+        params.cdpParams.cdpAssetSymbol.unCurrencySymbol + cdpD.iasset;
       const mintValue = {} as Assets;
       mintValue[iassetToken] = mintAmount;
 
@@ -476,7 +500,7 @@ export class CDPContract {
     }
 
     if (fee > 0n) {
-      await CollectorContract.feeTx(fee, lucid, params, tx, collectorRef)
+      await CollectorContract.feeTx(fee, lucid, params, tx, collectorRef);
     }
 
     return tx;
@@ -494,23 +518,16 @@ export class CDPContract {
     treasuryRef?: OutRef,
   ): Promise<TxBuilder> {
     // Find Pkh, Skh
-    const [pkh, skh] = await addrDetails(lucid);
+    const [pkh, _] = 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';
+    if (!cdp.datum) throw new Error('Unable to find CDP Datum');
+    const cdpDatum = parseCDPDatum(cdp.datum);
     const iAsset = await (assetRef
-      ? IAssetHelpers.findIAssetByRef(assetRef, params, lucid)
-      : IAssetHelpers.findIAssetByName(cdpDatum.asset, params, lucid));
+      ? IAssetHelpers.findIAssetByRef(assetRef, lucid)
+      : IAssetHelpers.findIAssetByName(cdpDatum.iasset, params, lucid));
 
     const gov = govRef
       ? (await lucid.utxosByOutRef([govRef]))[0]
@@ -518,87 +535,91 @@ export class CDPContract {
           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';
+
+    if (!gov.datum) throw new Error('Unable to find Gov Datum');
     const cdpScriptRefUtxo = await CDPContract.scriptRef(
       params.scriptReferences,
       lucid,
     );
 
-    const interestOracleAsset = iAsset.datum.interestOracle;
+    const interestOracleAsset = iAsset.datum.interestOracleNft;
     const interestOracleOut = interestOracleRef
       ? (await lucid.utxosByOutRef([interestOracleRef]))[0]
       : await lucid.utxoByUnit(
-          interestOracleAsset[0].unCurrencySymbol +
-            fromText(interestOracleAsset[1].unTokenName),
+          interestOracleAsset.currencySymbol +
+            fromText(interestOracleAsset.tokenName),
         );
     if (!interestOracleOut.datum)
-      return Promise.reject('Interest Oracle datum not found');
-    const interestOracleDatum =
-      InterestOracleContract.decodeInterestOracleDatum(interestOracleOut.datum);
+      return Promise.reject(new Error('Interest Oracle datum not found'));
+    const interestOracleDatum = parseInterestOracleDatum(
+      interestOracleOut.datum,
+    );
 
-    let tx = lucid
+    const 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';
+    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
-    const oracleAsset = iAsset.datum.price as AssetClass;
+    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[0].unCurrencySymbol +
-            fromText(oracleAsset[1].unTokenName),
+          oracleAsset.currencySymbol + fromText(oracleAsset.tokenName),
         );
 
     // 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');
+    if (!oracleRefInput.datum)
+      return Promise.reject(new Error('Invalid oracle input'));
+    const od = parsePriceOracleDatum(oracleRefInput.datum);
 
     // 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_ = now + Number(params.cdpCreatorParams.biasTime) - 1_000;
     const timeValidTo =
       cappedValidateTo <= timeValidFrom
         ? timeValidTo_
         : Math.min(timeValidTo_, Number(cappedValidateTo));
-    tx
-      .readFrom([oracleRefInput])
+    tx.readFrom([oracleRefInput])
       .validFrom(Number(timeValidFrom))
       .validTo(Number(timeValidTo));
 
     let fee = 0n;
 
     // Interest payment
-    const interestPaymentAsset = InterestOracleContract.calculateAccruedInterest(
+    const interestPaymentAsset = calculateAccruedInterest(
       BigInt(now),
-      cdpD.fees.unitary_interest_snapshot,
-      cdpD.mintedAmount,
-      cdpD.fees.last_settled,
+      cdpD.cdpFees.ActiveCDPInterestTracking.unitaryInterestSnapshot,
+      cdpD.mintedAmt,
+      cdpD.cdpFees.ActiveCDPInterestTracking.lastSettled,
       interestOracleDatum,
     );
-    const interestPayment = (interestPaymentAsset * od.price) / 1_000_000n;
+    const interestPayment =
+      (interestPaymentAsset * od.price.getOnChainInt) / 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);
+      await TreasuryContract.feeTx(
+        interestTreasuryPayment,
+        lucid,
+        params,
+        tx,
+        treasuryRef,
+      );
     }
 
     fee += interestCollectorPayment;
@@ -609,202 +630,30 @@ export class CDPContract {
       lucid,
     );
     const iassetToken =
-      params.cdpParams.cdpAssetSymbol.unCurrencySymbol + fromText(cdpD.asset);
+      params.cdpParams.cdpAssetSymbol.unCurrencySymbol + cdpD.iasset;
     const assetBurnValue = {} as Assets;
-    assetBurnValue[iassetToken] = -BigInt(cdpD.mintedAmount);
+    assetBurnValue[iassetToken] = -BigInt(cdpD.mintedAmt);
     const cdpTokenBurnValue = {} as Assets;
-    cdpTokenBurnValue[params.cdpParams.cdpAuthToken[0].unCurrencySymbol + fromText(params.cdpParams.cdpAuthToken[1].unTokenName)] = -1n;
+    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, [])),
-    );
+    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)
+      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,