@indigo-labs/indigo-sdk 0.1.0 → 0.1.1

package/package.json

@@ -1,13 +1,12 @@
 {
     "name": "@indigo-labs/indigo-sdk",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
     "scripts": {
-        "build": "tsc",
-        "build-tsup": "tsup src/index.ts --format esm,cjs --dts --clean",
+        "build": "tsup src/index.ts --format esm,cjs --dts --clean",
         "test": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
         "lint": "eslint .",
         "lint:fix": "eslint . --fix",

package/dist/contracts/cdp-creator.d.ts

@@ -1,9 +0,0 @@
-import { Address, Credential, Data, LucidEvolution, SpendingValidator, UTxO } from '@lucid-evolution/lucid';
-import { CdpCreatorParams, ScriptReferences } from '../types/system-params';
-export declare class CDPCreatorContract {
-    static address(params: CdpCreatorParams, lucid: LucidEvolution): Address;
-    static validator(params: CdpCreatorParams): SpendingValidator;
-    static validatorHash(params: CdpCreatorParams): string;
-    static redeemer(hash: Credential, mintedAmount: bigint, collateralAmount: bigint, currentTime: bigint): Data;
-    static scriptRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
-}

package/dist/contracts/cdp-creator.js

@@ -1,58 +0,0 @@
-import { applyParamsToScript, Constr, fromText, validatorToAddress, validatorToScriptHash, } from '@lucid-evolution/lucid';
-import { _cdpCreatorValidator } from '../scripts/cdp-creator-validator';
-import { scriptRef } from '../helpers/lucid-utils';
-export class CDPCreatorContract {
-    static address(params, lucid) {
-        const network = lucid.config().network;
-        if (!network) {
-            throw new Error('Network configuration is undefined');
-        }
-        return validatorToAddress(network, CDPCreatorContract.validator(params));
-    }
-    static validator(params) {
-        return {
-            type: 'PlutusV2',
-            script: applyParamsToScript(_cdpCreatorValidator.cborHex, [
-                new Constr(0, [
-                    new Constr(0, [
-                        params.cdpCreatorNft[0].unCurrencySymbol,
-                        fromText(params.cdpCreatorNft[1].unTokenName),
-                    ]),
-                    params.cdpAssetCs.unCurrencySymbol,
-                    new Constr(0, [
-                        params.cdpAuthTk[0].unCurrencySymbol,
-                        fromText(params.cdpAuthTk[1].unTokenName),
-                    ]),
-                    new Constr(0, [
-                        params.iAssetAuthTk[0].unCurrencySymbol,
-                        fromText(params.iAssetAuthTk[1].unTokenName),
-                    ]),
-                    new Constr(0, [
-                        params.versionRecordToken[0].unCurrencySymbol,
-                        fromText(params.versionRecordToken[1].unTokenName),
-                    ]),
-                    params.cdpScriptHash,
-                    params.collectorValHash,
-                    BigInt(params.minCollateralInLovelace),
-                    BigInt(params.biasTime),
-                ]),
-            ]),
-        };
-    }
-    static validatorHash(params) {
-        return validatorToScriptHash(CDPCreatorContract.validator(params));
-    }
-    static redeemer(hash, mintedAmount, collateralAmount, currentTime) {
-        if (hash.type !== 'Key')
-            throw new Error('Cannot support script hash.');
-        return new Constr(0, [
-            hash.hash,
-            BigInt(mintedAmount),
-            BigInt(collateralAmount),
-            currentTime
-        ]);
-    }
-    static scriptRef(params, lucid) {
-        return scriptRef(params.cdpCreatorValidatorRef, lucid);
-    }
-}

package/dist/contracts/cdp.d.ts

@@ -1,22 +0,0 @@
-import { Constr, Credential, Data, LucidEvolution, OutRef, SpendingValidator, TxBuilder, UTxO } from '@lucid-evolution/lucid';
-import { CdpParams, ScriptReferences, SystemParams } from '../types/system-params';
-import { CDPDatum, CDPFees } from '../types/indigo/cdp';
-export declare class CDPContract {
-    static openPosition(asset: string, collateralAmount: bigint, mintedAmount: bigint, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, cdpCreatorRef?: OutRef, collectorRef?: OutRef): Promise<TxBuilder>;
-    static deposit(cdpRef: OutRef, amount: bigint, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, collectorRef?: OutRef, govRef?: OutRef, treasuryRef?: OutRef): Promise<TxBuilder>;
-    static withdraw(cdpRef: OutRef, amount: bigint, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, collectorRef?: OutRef, govRef?: OutRef, treasuryRef?: OutRef): Promise<TxBuilder>;
-    static mint(cdpRef: OutRef, amount: bigint, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, collectorRef?: OutRef, govRef?: OutRef, treasuryRef?: OutRef): Promise<TxBuilder>;
-    static burn(cdpRef: OutRef, amount: bigint, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, collectorRef?: OutRef, govRef?: OutRef, treasuryRef?: OutRef): Promise<TxBuilder>;
-    static 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>;
-    static close(cdpRef: OutRef, params: SystemParams, lucid: LucidEvolution, assetRef?: OutRef, priceOracleRef?: OutRef, interestOracleRef?: OutRef, collectorRef?: OutRef, govRef?: OutRef, treasuryRef?: OutRef): Promise<TxBuilder>;
-    static decodeCdpDatum(datum: string): CDPDatum;
-    static encodeCdpDatum(datum: CDPDatum): string;
-    static datum(hash: Credential, asset: string, mintedAmount: bigint, fees: CDPFees): Constr<Data>;
-    static validator(params: CdpParams): SpendingValidator;
-    static validatorHash(params: CdpParams): string;
-    static address(cdpParams: CdpParams, lucid: LucidEvolution, skh?: Credential): string;
-    static scriptRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
-    static cdpAuthTokenRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
-    static assetTokenRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
-    static assetAuthTokenRef(params: ScriptReferences, lucid: LucidEvolution): Promise<UTxO>;
-}

package/dist/contracts/cdp.js

@@ -1,542 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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>;
-}