@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/initialize/types.ts

@@ -1,18 +1,57 @@
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import { InterestOracleParams } from '../interest-oracle/types';
 import { PriceOracleParams } from '../price-oracle/types';
+import { Rational } from '../../types/rational';
+import { PythFeedParamsSP } from '../../types/system-params';
 
-/**
- * Configuration for an asset to be initialized on the Indigo Protocol.
- */
-export type InitialAsset = {
-  name: string;
-  priceOracle: {
-    tokenName: string;
-    startPrice: bigint;
-    params: {
-      biasTime: bigint;
-      expirationTime: bigint;
-    };
+export type CollateralAssetInfo = {
+  collateralAsset: AssetClass;
+  oracleParams: PriceOracleParams | undefined;
+  interestOracleParams: InterestOracleParams;
+  interestOracleNft: AssetClass;
+};
+
+export type AssetInfo = {
+  iassetTokenNameAscii: string;
+  collateralAssets: CollateralAssetInfo[];
+};
+
+/** Price oracle config for indigo oracle (used during initialize) */
+export type IndigoOracleNftParam = {
+  tag: '_indigo_oracle_nft';
+  tokenName: string;
+  startPrice: Rational;
+  params: {
+    biasTime: bigint;
+    expirationPeriod: bigint;
   };
+};
+
+/** Price oracle config for Pyth (used during initialize) */
+export type PythOracleParam = {
+  tag: '_pyth_oracle_nft';
+  pythFeedParams: PythFeedParamsSP;
+};
+
+export type PriceOracleParam = IndigoOracleNftParam | PythOracleParam;
+
+export type InitialStablepoolParam = {
+  collateralAsset: AssetClass;
+  collateralToIassetRatio: Rational;
+  mintingFeeRatio: Rational;
+  redemptionFeeRatio: Rational;
+  mintingEnabled: boolean;
+  redemptionEnabled: boolean;
+  feeManager: string | undefined;
+  minMintOrderAmount: bigint;
+  minRedemptionOrderAmount: bigint;
+};
+
+/** Collateral asset input for initialize */
+export type InitialCollateralAssetParam = {
+  collateralAsset: AssetClass;
+  extraDecimals: bigint;
+  priceOracle: PriceOracleParam;
   interestOracle: {
     tokenName: string;
     initialInterestRate: bigint;
@@ -20,23 +59,58 @@ export type InitialAsset = {
       biasTime: bigint;
     };
   };
-  redemptionRatioPercentage: bigint;
-  maintenanceRatioPercentage: bigint;
-  liquidationRatioPercentage: bigint;
-  debtMintingFeePercentage: bigint;
-  liquidationProcessingFeePercentage: bigint;
-  stabilityPoolWithdrawalFeePercentage: bigint;
-  redemptionReimbursementPercentage: bigint;
-  redemptionProcessingFeePercentage: bigint;
-  interestCollectorPortionPercentage: bigint;
+  redemptionRatio: Rational;
+  maintenanceRatio: Rational;
+  liquidationRatio: Rational;
+  minCollateralAmt: bigint;
+  firstCollateralAsset: boolean;
+  nextCollateralAsset: AssetClass | undefined;
+};
+
+/** IAsset input for initialize */
+export type InitialAssetParam = {
+  name: string;
+  collateralAssets: InitialCollateralAssetParam[];
+  stablepools: InitialStablepoolParam[];
+  debtMintingFeeRatio: Rational;
+  liquidationProcessingFeeRatio: Rational;
+  stabilityPoolWithdrawalFeeRatio: Rational;
+  redemptionReimbursementRatio: Rational;
+  redemptionProcessingFeeRatio: Rational;
   firstAsset: boolean;
-  nextAsset?: string;
+  nextAsset?: string | undefined;
 };
 
-/**
- * Result of initializing a single asset (iAsset + stability pool + oracles).
- */
-export type AssetInfo = {
-  iassetTokenNameAscii: string;
-  oracleParams: PriceOracleParams;
+/** Configurable options for protocol initialization */
+export type InitializeOptions = {
+  /** Number of CDP creator UTxOs to create */
+  numCdpCreators: bigint;
+  /** Number of collector UTxOs to create */
+  numCollectors: bigint;
+  /** Number of interest collector UTxOs to create */
+  numInterestCollectors: bigint;
+  /** Number of treasury UTxo deployments */
+  numTreasuryUtxos: bigint;
+  /** INDY amount to send to the treasury */
+  treasuryIndyAmount: bigint;
+  /** Total INDY token supply to mint */
+  totalIndySupply: bigint;
+
+  /** Stability pool: fee in lovelace to create an SP account */
+  accountCreateFeeLovelaces: bigint;
+  /** Stability pool: cooldown between account processing (ms) */
+  accountProcessingCooldownMs: bigint;
+
+  /** Interest collection: cooldown between interest settlement (slot) */
+  interestSettlementCooldown: bigint;
+
+  /** CDP redeem: extra fee in lovelace for partial redemption */
+  partialRedemptionExtraFeeLovelace: number;
+  /** Default Protocol bias time (ms). Used for CDP, CDP Redeem, Stability Pool, Interest Collection, Interest Oracle, Price Oracle, and Stableswap. */
+  biasTime: bigint;
+  gBiasTime?: bigint;
+  accountProcessingBiasTime?: bigint;
+
+  /** Lovelace per interest collector deployment UTxO */
+  interestCollectorUtxoLovelaces: bigint;
 };

package/src/contracts/interest-collection/helpers.ts

@@ -0,0 +1,19 @@
+import { toHex } from '@lucid-evolution/lucid';
+import { fromDataMultisig, Multisig } from '../../types/multisig';
+import { Data } from '@evolution-sdk/evolution';
+
+export function signersAllOf(multisig: Multisig): string[] {
+  if ('Signature' in multisig) {
+    return [toHex(multisig.Signature.keyHash)];
+  } else {
+    return multisig.AtLeast.authSignatories
+      .map((signatory: Data.Data) => {
+        try {
+          return signersAllOf(fromDataMultisig(signatory));
+        } catch {
+          return [];
+        }
+      })
+      .flat();
+  }
+}

package/src/contracts/interest-collection/scripts.ts

@@ -0,0 +1,44 @@
+import { applyParamsToScript } from '@lucid-evolution/lucid';
+import { SpendingValidator } from '@lucid-evolution/lucid';
+import { _interestCollectionValidator } from '../../validators/interest-collection-validator';
+import {
+  castInterestCollectionParams,
+  InterestCollectionParams,
+} from './types';
+import {
+  fromSystemParamsAssetLucid,
+  InterestCollectionParamsSP,
+} from '../../types/system-params';
+
+export function mkInterestCollectionValidator(
+  params: InterestCollectionParams,
+): SpendingValidator {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_interestCollectionValidator.cborHex, [
+      castInterestCollectionParams(params),
+    ]),
+  };
+}
+
+export const mkInterestCollectionValidatorFromSP = (
+  params: InterestCollectionParamsSP,
+): SpendingValidator => {
+  return {
+    type: 'PlutusV3',
+    script: applyParamsToScript(_interestCollectionValidator.cborHex, [
+      castInterestCollectionParams({
+        versionRecordNft: fromSystemParamsAssetLucid(params.versionRecordNft),
+        multisigUtxoNft: fromSystemParamsAssetLucid(params.multisigUtxoNft),
+        cdpAuthTk: fromSystemParamsAssetLucid(params.cdpAuthTk),
+        collateralAssetAuthTk: fromSystemParamsAssetLucid(
+          params.collateralAssetAuthTk,
+        ),
+        govAuthTk: fromSystemParamsAssetLucid(params.govAuthTk),
+        cdpAssetSymbol: params.cdpAssetSymbol.unCurrencySymbol,
+        cdpBiasTime: BigInt(params.cdpBiasTime),
+        interestSettlementCooldown: BigInt(params.interestSettlementCooldown),
+      }),
+    ]),
+  };
+};

package/src/contracts/interest-collection/transactions.ts

@@ -0,0 +1,436 @@
+import {
+  Data,
+  LucidEvolution,
+  OutRef,
+  toHex,
+  TxBuilder,
+  UTxO,
+  addAssets,
+  Assets,
+  fromHex,
+  slotToUnixTime,
+  sortUTxOs,
+  getInputIndices,
+} from '@lucid-evolution/lucid';
+import {
+  fromSystemParamsAsset,
+  fromSystemParamsScriptRef,
+  SystemParams,
+} from '../../types/system-params';
+import { matchSingle } from '../../utils/utils';
+import {
+  parseInterestCollectionDatum,
+  serialiseInterestCollectionDatum,
+  serialiseInterestCollectionRedeemer,
+} from './types-new';
+import {
+  assetClassValueOf,
+  getInlineDatumOrThrow,
+  mkAssetsOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { createScriptAddress } from '../../utils/lucid-utils';
+import {
+  CDPContent,
+  parseCdpDatumOrThrow,
+  serialiseCdpDatum,
+  serialiseCdpRedeemer,
+} from '../cdp/types-new';
+import { parseInterestOracleDatum } from '../interest-oracle/types-new';
+import {
+  calculateAccruedInterest,
+  calculateUnitaryInterestSinceOracleLastUpdated,
+} from '../interest-oracle/helpers';
+import { match, P } from 'ts-pattern';
+import { array as A, function as F } from 'fp-ts';
+import { parseCollateralAssetDatumOrThrow } from '../iasset/types';
+import { Multisig } from '../../types/multisig';
+
+type CDPInfo = {
+  utxo: UTxO;
+  datum: CDPContent;
+  accruedInterest: bigint;
+};
+
+export async function batchCollectInterest(
+  collateralAssetOref: OutRef,
+  interestCollectorOutRef: OutRef,
+  interestOracleOutRef: OutRef,
+  cdpOutRefs: OutRef[],
+  params: SystemParams,
+  lucid: LucidEvolution,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, currentSlot));
+
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  const cdpRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.cdpValidatorRef),
+    ]),
+    (_) => new Error('Expected a single cdp Ref Script UTXO'),
+  );
+
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.iAssetTokenPolicyRef),
+    ]),
+    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
+  );
+
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOref]),
+    (_) => new Error('Expected a single iasset UTXO'),
+  );
+
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo),
+  );
+
+  const interestCollectorUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([interestCollectorOutRef]),
+    (_) => new Error('Expected a single interest collector UTXO'),
+  );
+
+  // Confirm that the interest collector UTXO is NOT of InterestCollectorDatum type
+  if (
+    assetClassValueOf(
+      interestCollectorUtxo.assets,
+      fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+    )
+  ) {
+    throw new Error(
+      'Interest collector UTXO is of InterestCollectorDatum type',
+    );
+  }
+
+  const interestOracleUtxo: UTxO = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOutRef]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
+  );
+
+  const interestOracleDatum = parseInterestOracleDatum(
+    getInlineDatumOrThrow(interestOracleUtxo),
+  );
+
+  const cdpUtxos = await lucid.utxosByOutRef(cdpOutRefs);
+
+  const sortedCdpUtxos = sortUTxOs(cdpUtxos, 'Canonical');
+
+  if (sortedCdpUtxos.length !== cdpOutRefs.length) {
+    throw new Error('Expected certain number of CDPs');
+  }
+
+  function getAccruedInterest(cdpDatum: CDPContent): bigint {
+    return match(cdpDatum.cdpFees)
+      .with({ FrozenCDPAccumulatedFees: P.any }, () => {
+        throw new Error('CDP fees wrong');
+      })
+      .with({ ActiveCDPInterestTracking: P.select() }, (interest) => {
+        return calculateAccruedInterest(
+          currentTime,
+          interest.unitaryInterestSnapshot,
+          cdpDatum.mintedAmt,
+          interest.lastSettled,
+          interestOracleDatum,
+        );
+      })
+      .exhaustive();
+  }
+
+  const cdpsInfo: CDPInfo[] = sortedCdpUtxos.map((cdpUtxo) => {
+    const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
+    return {
+      utxo: cdpUtxo,
+      datum: cdpDatum,
+      accruedInterest: getAccruedInterest(cdpDatum),
+    };
+  });
+
+  const accumulatedInterest = F.pipe(
+    cdpsInfo,
+    A.reduce<CDPInfo, bigint>(
+      0n,
+      (acc, cdpInfo) => acc + cdpInfo.accruedInterest,
+    ),
+  );
+
+  const updatedUnitarySnapshot =
+    calculateUnitaryInterestSinceOracleLastUpdated(
+      currentTime,
+      interestOracleDatum,
+    ) + interestOracleDatum.unitaryInterest;
+
+  const referenceInputs = [
+    collateralAssetUtxo,
+    interestOracleUtxo,
+    interestCollectionRefScriptUtxo,
+    cdpRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+  ];
+
+  const referenceInputIndices = getInputIndices(
+    [collateralAssetUtxo, interestOracleUtxo],
+    referenceInputs,
+    false,
+  );
+
+  const validateFrom = slotToUnixTime(network, currentSlot - 1);
+  const validateTo = validateFrom + Number(params.cdpParams.biasTime);
+
+  const tx = lucid
+    .newTx()
+    .validFrom(validateFrom)
+    .validTo(validateTo)
+    .readFrom(referenceInputs)
+    .collectFrom([interestCollectorUtxo], {
+      kind: 'selected',
+      makeRedeemer: (inputIndices: bigint[]) => {
+        return serialiseInterestCollectionRedeemer({
+          BatchCollectInterest: {
+            currentTime: currentTime,
+            ownInputIndex: inputIndices[0],
+            collateralAssetRefInputIndex: referenceInputIndices[0],
+            interestOracleRefInputIndex: referenceInputIndices[1],
+          },
+        });
+      },
+      inputs: [interestCollectorUtxo],
+    })
+    .mintAssets(
+      mkAssetsOf(
+        {
+          currencySymbol: fromHex(
+            params.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+          ),
+          tokenName: collateralAssetDatum.iasset,
+        },
+        accumulatedInterest,
+      ),
+      Data.void(),
+    )
+    .pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        params.validatorHashes.interestCollectionHash,
+      ),
+      { kind: 'inline', value: Data.void() },
+      addAssets(
+        interestCollectorUtxo.assets,
+        mkAssetsOf(
+          {
+            currencySymbol: fromHex(
+              params.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+            ),
+            tokenName: collateralAssetDatum.iasset,
+          },
+          accumulatedInterest,
+        ),
+      ),
+    );
+
+  F.pipe(
+    cdpsInfo,
+    A.reduce<CDPInfo, TxBuilder>(tx, (acc, cdpInfo) =>
+      acc
+        .collectFrom([cdpInfo.utxo], {
+          kind: 'selected',
+          makeRedeemer: (inputIndices: bigint[]) => {
+            return serialiseCdpRedeemer({
+              SettleInterest: { interestCollectorInputIndex: inputIndices[0] },
+            });
+          },
+          inputs: [interestCollectorUtxo],
+        })
+        .pay.ToContract(
+          cdpInfo.utxo.address,
+          {
+            kind: 'inline',
+            value: serialiseCdpDatum({
+              ...cdpInfo.datum,
+              mintedAmt: cdpInfo.datum.mintedAmt + cdpInfo.accruedInterest,
+              cdpFees: {
+                ActiveCDPInterestTracking: {
+                  lastSettled: currentTime,
+                  unitaryInterestSnapshot: updatedUnitarySnapshot,
+                },
+              },
+            }),
+          },
+          cdpInfo.utxo.assets,
+        ),
+    ),
+  );
+
+  return tx;
+}
+
+export async function collectInterestTx(
+  value: Assets,
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  tx: TxBuilder,
+  interestCollectorOref: OutRef,
+): Promise<UTxO> {
+  const interestCollectorUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestCollectorOref]),
+    (_) => new Error('Expected a single interest collector UTXO'),
+  );
+  const interestCollectorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collector Ref Script UTXO'),
+  );
+
+  tx.readFrom([interestCollectorRefScriptUtxo])
+    .collectFrom(
+      [interestCollectorUtxo],
+      serialiseInterestCollectionRedeemer('CollectInterest'),
+    )
+    .pay.ToContract(
+      interestCollectorUtxo.address,
+      { kind: 'inline', value: Data.void() },
+      addAssets(interestCollectorUtxo.assets, value),
+    );
+
+  return interestCollectorRefScriptUtxo;
+}
+
+export async function distributeInterest(
+  interestCollectorOutRefs: OutRef[],
+  interestAdminOutRef: OutRef,
+  params: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const interestCollectorUtxos = [];
+
+  for (const outRef of interestCollectorOutRefs) {
+    interestCollectorUtxos.push(
+      matchSingle(
+        await lucid.utxosByOutRef([outRef]),
+        (_) => new Error('Expected a single UTXO with that reference'),
+      ),
+    );
+  }
+
+  const interestAdminUtxo: UTxO = matchSingle(
+    (await lucid.utxosByOutRef([interestAdminOutRef])).filter((utxo) =>
+      assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+      ),
+    ),
+    (_) => new Error('Expected a single interest admin UTXO'),
+  );
+
+  const interestAdminDatum = parseInterestCollectionDatum(
+    getInlineDatumOrThrow(interestAdminUtxo),
+  );
+
+  // Find the script reference UTXO for the interest collection validator
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([interestCollectionRefScriptUtxo, interestAdminUtxo])
+    .collectFrom(
+      interestCollectorUtxos,
+      serialiseInterestCollectionRedeemer('Distribute'),
+    );
+
+  // TODO: Handle tx contruction for Multisig
+  if ('Signature' in interestAdminDatum.admin_permissions) {
+    tx.addSignerKey(
+      toHex(interestAdminDatum.admin_permissions.Signature.keyHash),
+    );
+  } else {
+    // TODO: Handle other admin permissions types
+    throw new Error('Unsupported admin permissions type');
+  }
+
+  return tx;
+}
+
+export async function updatePermissions(
+  interestAdminOutRef: OutRef,
+  govOref: OutRef,
+  newAdminPermissions: Multisig,
+  expectedSigners: string[],
+  params: SystemParams,
+  lucid: LucidEvolution,
+): Promise<TxBuilder> {
+  const interestAdminUtxo: UTxO = matchSingle(
+    (await lucid.utxosByOutRef([interestAdminOutRef])).filter((utxo) =>
+      assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(params.interestCollectionParams.multisigUtxoNft),
+      ),
+    ),
+    (_) => new Error('Expected a single interest admin UTXO'),
+  );
+
+  const govUtxo: UTxO = matchSingle(
+    (await lucid.utxosByOutRef([govOref])).filter((utxo) =>
+      assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(params.interestCollectionParams.govAuthTk),
+      ),
+    ),
+    (_) => new Error('Expected a single interest admin UTXO'),
+  );
+
+  // Find the script reference UTXO for the interest collection validator
+  const interestCollectionRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        params.scriptReferences.interestCollectionValidatorRef,
+      ),
+    ]),
+    (_) => new Error('Expected a single interest collection Ref Script UTXO'),
+  );
+
+  const tx = lucid
+    .newTx()
+    .readFrom([interestCollectionRefScriptUtxo, govUtxo])
+    .collectFrom(
+      [interestAdminUtxo],
+      serialiseInterestCollectionRedeemer('UpdatePermissions'),
+    )
+    .pay.ToContract(
+      createScriptAddress(
+        lucid.config().network!,
+        params.validatorHashes.interestCollectionHash,
+      ),
+      {
+        kind: 'inline',
+        value: serialiseInterestCollectionDatum({
+          admin_permissions: newAdminPermissions,
+        }),
+      },
+      interestAdminUtxo.assets,
+    );
+
+  for (const signer of expectedSigners) {
+    tx.addSignerKey(signer);
+  }
+
+  return tx;
+}

package/src/contracts/interest-collection/types-new.ts

@@ -0,0 +1,50 @@
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import { MultisigSchema } from '../../types/multisig';
+
+const InterestCollectionDatumSchema = TSchema.Struct({
+  admin_permissions: MultisigSchema,
+});
+
+export type InterestCollectionDatum = typeof InterestCollectionDatumSchema.Type;
+
+const InterestCollectionRedeemerSchema = TSchema.Union(
+  TSchema.Literal('CollectInterest', { flatInUnion: true }),
+  TSchema.Struct(
+    {
+      BatchCollectInterest: TSchema.Struct(
+        {
+          currentTime: TSchema.Integer,
+          ownInputIndex: TSchema.Integer,
+          collateralAssetRefInputIndex: TSchema.Integer,
+          interestOracleRefInputIndex: TSchema.Integer,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Literal('Distribute', { flatInUnion: true }),
+  TSchema.Literal('UpdatePermissions', { flatInUnion: true }),
+  TSchema.Literal('UpgradeVersion', { flatInUnion: true }),
+);
+
+export type InterestCollectionRedeemer =
+  typeof InterestCollectionRedeemerSchema.Type;
+
+export function serialiseInterestCollectionRedeemer(
+  redeemer: InterestCollectionRedeemer,
+): string {
+  return Data.withSchema(InterestCollectionRedeemerSchema).toCBORHex(redeemer);
+}
+
+export function parseInterestCollectionDatum(
+  datum: string,
+): InterestCollectionDatum {
+  return Data.withSchema(InterestCollectionDatumSchema).fromCBORHex(datum);
+}
+
+export function serialiseInterestCollectionDatum(
+  datum: InterestCollectionDatum,
+): string {
+  return Data.withSchema(InterestCollectionDatumSchema).toCBORHex(datum);
+}