@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/src/contracts/initialize/types.ts

@@ -1,116 +0,0 @@
-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';
-
-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;
-    params: {
-      biasTime: 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 | undefined;
-};
-
-/** 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

@@ -1,19 +0,0 @@
-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/queries.ts

@@ -1,66 +0,0 @@
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { option as O, function as F } from 'fp-ts';
-import {
-  assetClassToUnit,
-  assetClassValueOf,
-  getRandomElement,
-  matchSingle,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { createScriptAddress } from '../../utils/lucid-utils';
-import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
-
-export async function findAllInterestCollectors(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO[]> {
-  return lucid.utxosAt(
-    createScriptAddress(
-      lucid.config().network!,
-      sysParams.validatorHashes.interestCollectionHash,
-    ),
-  );
-}
-
-export async function findAdminInterestCollectors(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  return matchSingle(
-    await lucid.utxosAtWithUnit(
-      createScriptAddress(
-        lucid.config().network!,
-        sysParams.validatorHashes.interestCollectionHash,
-      ),
-      assetClassToUnit(
-        fromSystemParamsAsset(
-          sysParams.interestCollectionParams.multisigUtxoNft,
-        ),
-      ),
-    ),
-    (_) => new Error('Expected a single admin interest collector UTXO'),
-  );
-}
-
-export async function findRandomNonAdminInterestCollector(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  const allCollectors = (
-    await findAllInterestCollectors(lucid, sysParams)
-  ).filter(
-    (utxo) =>
-      !assetClassValueOf(
-        utxo.assets,
-        fromSystemParamsAsset(
-          sysParams.interestCollectionParams.multisigUtxoNft,
-        ),
-      ),
-  );
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(allCollectors)),
-    O.match(() => {
-      throw new Error('Expected some non-admin interest collector UTXOs.');
-    }, F.identity),
-  );
-}

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

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

@@ -1,433 +0,0 @@
-import {
-  Data,
-  LucidEvolution,
-  OutRef,
-  toHex,
-  TxBuilder,
-  UTxO,
-  addAssets,
-  Assets,
-  fromHex,
-  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,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.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 = lucid.slotToUnixTime(lucid.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;
-}