@indigo-labs/indigo-sdk 0.1.0

package/dist/contracts/cdp.js

@@ -0,0 +1,542 @@
+import { applyParamsToScript, Constr, Data, fromText, toText, validatorToAddress, validatorToScriptHash, } from '@lucid-evolution/lucid';
+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 { calculateFeeFromPercentage } from '../helpers/helpers';
+import { _cdpValidator } from '../scripts/cdp-validator';
+export class CDPContract {
+    static async openPosition(asset, collateralAmount, mintedAmount, params, lucid, assetRef, priceOracleRef, interestOracleRef, cdpCreatorRef, collectorRef) {
+        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;
+        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 = {
+            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 = {};
+        cdpTokenMintValue[cdpToken] = 1n;
+        const iassetTokenMintValue = {};
+        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 - 20001n;
+        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, amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        return CDPContract.adjust(cdpRef, amount, 0n, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef);
+    }
+    static async withdraw(cdpRef, amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        return CDPContract.adjust(cdpRef, -amount, 0n, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef);
+    }
+    static async mint(cdpRef, amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        return CDPContract.adjust(cdpRef, 0n, amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef);
+    }
+    static async burn(cdpRef, amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        return CDPContract.adjust(cdpRef, 0n, -amount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef);
+    }
+    static async adjust(cdpRef, collateralAmount, mintAmount, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        // 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_ = {
+            ...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;
+        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 - 20001n;
+        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) / 1000000n;
+        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 = {};
+            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, params, lucid, assetRef, priceOracleRef, interestOracleRef, collectorRef, govRef, treasuryRef) {
+        // 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;
+        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 - 20001n;
+        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) / 1000000n;
+        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 = {};
+        assetBurnValue[iassetToken] = -BigInt(cdpD.mintedAmount);
+        const cdpTokenBurnValue = {};
+        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) {
+        const cdpDatum = Data.from(datum);
+        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) {
+        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, asset, mintedAmount, fees) {
+        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) {
+        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) {
+        return validatorToScriptHash(CDPContract.validator(params));
+    }
+    static address(cdpParams, lucid, skh) {
+        const network = lucid.config().network;
+        if (!network) {
+            throw new Error('Network configuration is undefined');
+        }
+        return validatorToAddress(network, CDPContract.validator(cdpParams), skh);
+    }
+    static scriptRef(params, lucid) {
+        return scriptRef(params.cdpValidatorRef, lucid);
+    }
+    static cdpAuthTokenRef(params, lucid) {
+        return scriptRef(params.authTokenPolicies.cdpAuthTokenRef, lucid);
+    }
+    static assetTokenRef(params, lucid) {
+        return scriptRef(params.iAssetTokenPolicyRef, lucid);
+    }
+    static assetAuthTokenRef(params, lucid) {
+        return scriptRef(params.authTokenPolicies.iAssetTokenRef, lucid);
+    }
+}

package/dist/contracts/collector.d.ts

@@ -0,0 +1,9 @@
+import { Address, LucidEvolution, OutRef, SpendingValidator, TxBuilder, UTxO } from '@lucid-evolution/lucid';
+import { CollectorParams, ScriptReferences, SystemParams } from '../types/system-params';
+export declare class CollectorContract {
+    static feeTx(fee: bigint, lucid: LucidEvolution, params: SystemParams, tx: TxBuilder, collectorRef?: OutRef): Promise<void>;
+    static validator(params: CollectorParams): SpendingValidator;
+    static validatorHash(params: CollectorParams): string;
+    static address(params: CollectorParams, lucid: LucidEvolution): Address;
+    static scriptRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
+}

package/dist/contracts/collector.js

@@ -0,0 +1,52 @@
+import { applyParamsToScript, Constr, Data, fromText, validatorToAddress, validatorToScriptHash, } from '@lucid-evolution/lucid';
+import { _collectorValidator } from '../scripts/collector-validator';
+import { getRandomElement, scriptRef } from '../helpers/lucid-utils';
+export class CollectorContract {
+    static async feeTx(fee, lucid, params, tx, collectorRef) {
+        const collectorUtxo = collectorRef
+            ? getRandomElement(await lucid.utxosByOutRef([collectorRef]))
+            : getRandomElement(await lucid.utxosAt(CollectorContract.address(params.collectorParams, lucid)));
+        const collectorScriptRefUtxo = await CollectorContract.scriptRef(params.scriptReferences, lucid);
+        tx.collectFrom([collectorUtxo], Data.to(new Constr(0, [])))
+            .pay.ToContract(collectorUtxo.address, { kind: 'inline', value: Data.to(new Constr(0, [])) }, {
+            ...collectorUtxo.assets,
+            lovelace: collectorUtxo.assets['lovelace'] + fee,
+        })
+            .readFrom([collectorScriptRefUtxo]);
+    }
+    // Collector Validator
+    static validator(params) {
+        return {
+            type: 'PlutusV2',
+            script: applyParamsToScript(_collectorValidator.cborHex, [
+                new Constr(0, [
+                    new Constr(0, [
+                        params.stakingManagerNFT[0].unCurrencySymbol,
+                        fromText(params.stakingManagerNFT[1].unTokenName),
+                    ]),
+                    new Constr(0, [
+                        params.stakingToken[0].unCurrencySymbol,
+                        fromText(params.stakingToken[1].unTokenName),
+                    ]),
+                    new Constr(0, [
+                        params.versionRecordToken[0].unCurrencySymbol,
+                        fromText(params.versionRecordToken[1].unTokenName),
+                    ]),
+                ]),
+            ]),
+        };
+    }
+    static validatorHash(params) {
+        return validatorToScriptHash(CollectorContract.validator(params));
+    }
+    static address(params, lucid) {
+        const network = lucid.config().network;
+        if (!network) {
+            throw new Error('Network configuration is undefined');
+        }
+        return validatorToAddress(network, CollectorContract.validator(params));
+    }
+    static async scriptRef(params, lucid) {
+        return scriptRef(params.collectorValidatorRef, lucid);
+    }
+}

package/dist/contracts/gov.d.ts

@@ -0,0 +1,5 @@
+import { GovDatum } from '../types/indigo/gov';
+export declare class GovContract {
+    static decodeGovDatum(datum: string): GovDatum;
+    static encodeGovDatum(datum: GovDatum): string;
+}

package/dist/contracts/gov.js

@@ -0,0 +1,50 @@
+import { Constr, Data } from '@lucid-evolution/lucid';
+export class GovContract {
+    static decodeGovDatum(datum) {
+        const d = Data.from(datum);
+        if (d.index !== 0 ||
+            d.fields.length !== 6 ||
+            d.fields[1].fields.length !== 10)
+            throw 'Invalid GovDatum found';
+        return {
+            currentProposal: d.fields[0],
+            protocolParams: {
+                proposalDeposit: d.fields[1].fields[0],
+                votingPeriod: d.fields[1].fields[1],
+                effectiveDelay: d.fields[1].fields[2],
+                expirationPeriod: d.fields[1].fields[3],
+                collateralFeePercentage: d.fields[1].fields[4].fields[0],
+                proposingPeriod: d.fields[1].fields[5],
+                totalShards: d.fields[1].fields[6],
+                minimumQuorum: d.fields[1].fields[7],
+                maxTreasuryLovelaceSpend: d.fields[1].fields[8],
+                maxTreasuryIndySpend: d.fields[1].fields[9],
+            },
+            currentVersion: d.fields[2],
+            iassetsCount: d.fields[3],
+            activeProposals: d.fields[4],
+            treasuryIndyWithdrawnAmt: d.fields[5],
+        };
+    }
+    static encodeGovDatum(datum) {
+        return Data.to(new Constr(0, [
+            datum.currentProposal,
+            new Constr(0, [
+                datum.protocolParams.proposalDeposit,
+                datum.protocolParams.votingPeriod,
+                datum.protocolParams.effectiveDelay,
+                datum.protocolParams.expirationPeriod,
+                new Constr(0, [datum.protocolParams.collateralFeePercentage]),
+                datum.protocolParams.proposingPeriod,
+                datum.protocolParams.totalShards,
+                datum.protocolParams.minimumQuorum,
+                datum.protocolParams.maxTreasuryLovelaceSpend,
+                datum.protocolParams.maxTreasuryIndySpend,
+            ]),
+            datum.currentVersion,
+            datum.iassetsCount,
+            datum.activeProposals,
+            datum.treasuryIndyWithdrawnAmt,
+        ]));
+    }
+}

package/dist/contracts/interest-oracle.d.ts

@@ -0,0 +1,8 @@
+import { InterestOracleDatum } from "../types/indigo/interest-oracle";
+export declare class InterestOracleContract {
+    static decodeInterestOracleDatum(datum: string): InterestOracleDatum;
+    static encodeInterestOracleDatum(datum: InterestOracleDatum): string;
+    static calculateUnitaryInterestSinceOracleLastUpdated(now: bigint, oracleDatum: InterestOracleDatum): bigint;
+    static calculateUnitaryInterest(timePeriod: bigint, interestRate: bigint): bigint;
+    static calculateAccruedInterest(now: bigint, unitaryInterestSnapshot: bigint, mintedAmount: bigint, interestLastSettled: bigint, interestOracleDatum: InterestOracleDatum): bigint;
+}