@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/tests/cdp/cdp-queries.ts

@@ -0,0 +1,440 @@
+import {
+  Credential,
+  fromText,
+  LucidEvolution,
+  ScriptHash,
+  toHex,
+  toText,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  addrDetails,
+  adjustPriceToDecimals,
+  cdpCollateralRatioPercentage,
+  createScriptAddress,
+  fromSystemParamsAsset,
+  getRandomElement,
+  matchSingle,
+  SystemParams,
+} from '../../src';
+import { option as O, array as A, function as F } from 'fp-ts';
+import {
+  CDPContent,
+  parseCdpDatum,
+  parseStableswapPoolDatum,
+  StableswapPoolContent,
+} from '../../src/contracts/cdp/types-new';
+import { match, P } from 'ts-pattern';
+import {
+  AssetClass,
+  assetClassToUnit,
+  getInlineDatumOrThrow,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  InterestOracleDatum,
+  parseInterestOracleDatum,
+} from '../../src/contracts/interest-oracle/types-new';
+import { findCollateralAsset, findIAsset } from '../queries/iasset-queries';
+import { findStabilityPool } from '../queries/stability-pool-queries';
+import { findPriceOracle } from '../price-oracle/price-oracle-queries';
+import { findInterestOracle } from '../queries/interest-oracle-queries';
+import { findRandomCollector } from '../queries/collector-queries';
+import { findGov } from '../gov/governance-queries';
+import { findRandomTreasuryUtxoWithOnlyAda } from '../queries/treasury-queries';
+import { parsePriceOracleDatum } from '../../src/contracts/price-oracle/types-new';
+import {
+  CollateralAssetOutput,
+  IAssetOutput,
+} from '../../src/contracts/iasset/types';
+import { findRandomNonAdminInterestCollector } from '../interest-collection/interest-collector-queries';
+import { LucidContext } from '../test-helpers';
+import { Rational } from '../../src/types/rational';
+
+export async function findAllActiveCdps(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  assetAscii: string,
+  stakeCred?: Credential,
+): Promise<{ utxo: UTxO; datum: CDPContent }[]> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.cdpHash,
+      stakeCred,
+    ),
+    assetClassToUnit(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken)),
+  );
+
+  return F.pipe(
+    cdpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseCdpDatum),
+        O.flatMap((datum) => {
+          if (toHex(datum.iasset) === fromText(assetAscii) && datum.cdpOwner) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}
+
+export async function findCdp(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+  ownerPkh: string,
+  stakeCred?: Credential,
+): Promise<{ utxo: UTxO; datum: CDPContent }> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpScriptHash, stakeCred),
+    assetClassToUnit(cdpNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      cdpUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseCdpDatum),
+          O.flatMap((datum) => {
+            if (datum.cdpOwner && toHex(datum.cdpOwner) === ownerPkh) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) => new Error('Expected a single CDP UTXO.: ' + JSON.stringify(res)),
+  );
+}
+
+// TODO: use the new variant defined below.
+export async function findOwnCdp(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+): Promise<{ utxo: UTxO; datum: CDPContent }> {
+  const [pkh, skh] = await addrDetails(lucid);
+  return findCdp(lucid, cdpScriptHash, cdpNft, pkh.hash, skh);
+}
+
+export async function findOwnCdpNew(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<{ utxo: UTxO; datum: CDPContent }> {
+  const [pkh, skh] = await addrDetails(lucid);
+  return findCdp(
+    lucid,
+    sysParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    pkh.hash,
+    skh,
+  );
+}
+
+export async function findFrozenCDPs(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+  assetAscii: string,
+): Promise<{ utxo: UTxO; datum: CDPContent }[]> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpScriptHash),
+    assetClassToUnit(cdpNft),
+  );
+
+  return F.pipe(
+    cdpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseCdpDatum),
+        O.flatMap((datum) => {
+          if (
+            datum.cdpOwner == null &&
+            toHex(datum.iasset) === fromText(assetAscii)
+          ) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}
+
+export async function findStableswapPool(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+  iassetName: string,
+  collateralAsset: AssetClass,
+): Promise<{ utxo: UTxO; datum: StableswapPoolContent }> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpScriptHash),
+    assetClassToUnit(cdpNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      cdpUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseStableswapPoolDatum),
+          O.flatMap((datum) => {
+            if (
+              toHex(datum.iasset) === iassetName &&
+              toHex(datum.collateralAsset.currencySymbol) ===
+                toHex(collateralAsset.currencySymbol) &&
+              toHex(datum.collateralAsset.tokenName) ===
+                toHex(collateralAsset.tokenName)
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error(
+        'Expected a single stableswap pool UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}
+
+export async function findAllCdpCreators(
+  lucid: LucidEvolution,
+  cdpCreatorScriptHash: string,
+  cdpCreatorNft: AssetClass,
+): Promise<UTxO[]> {
+  return lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpCreatorScriptHash),
+    assetClassToUnit(cdpCreatorNft),
+  );
+}
+
+// TODO: replace by the new variant defined below
+export async function findRandomCdpCreator(
+  lucid: LucidEvolution,
+  cdpCreatorScriptHash: string,
+  cdpCreatorNft: AssetClass,
+): Promise<UTxO> {
+  const cdpCreatorUtxos = await findAllCdpCreators(
+    lucid,
+    cdpCreatorScriptHash,
+    cdpCreatorNft,
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
+    O.match(() => {
+      throw new Error('Expected some cdp creator UTXOs.');
+    }, F.identity),
+  );
+}
+
+export async function findRandomCdpCreatorNew(
+  context: LucidContext,
+  sysParams: SystemParams,
+): Promise<UTxO> {
+  const cdpCreatorUtxos = await findAllCdpCreators(
+    context.lucid,
+    sysParams.validatorHashes.cdpCreatorHash,
+    fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
+    O.match(() => {
+      throw new Error('Expected some cdp creator UTXOs.');
+    }, F.identity),
+  );
+}
+
+export function findPriceOracleFromCollateralAsset(
+  lucid: LucidEvolution,
+  collateralAsset: CollateralAssetOutput,
+): Promise<UTxO | undefined> {
+  return match(collateralAsset.datum.priceInfo)
+    .with({ OracleNft: P.select() }, (oracleNft) =>
+      findPriceOracle(lucid, oracleNft),
+    )
+    .with({ Delisted: P.any }, () => {
+      throw new Error('Cannot find price oracle as iAsset is delisted');
+    })
+    .otherwise(() => Promise.resolve(undefined));
+}
+
+export async function findAllNecessaryOrefs(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  iasset: string,
+  collateralAsset: AssetClass,
+): Promise<{
+  stabilityPoolUtxo: UTxO;
+  iasset: IAssetOutput;
+  collateralAsset: CollateralAssetOutput;
+  cdpCreatorUtxo: UTxO;
+  interestOracleUtxo: UTxO;
+  collectorUtxo: UTxO;
+  interestCollectorUtxo: UTxO;
+  govUtxo: UTxO;
+  treasuryUtxo: UTxO;
+}> {
+  const iassetOut = await findIAsset(
+    lucid,
+    sysParams.validatorHashes.iassetHash,
+    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    iasset,
+  );
+
+  const collateralAssetOut = await findCollateralAsset(
+    lucid,
+    sysParams,
+    fromSystemParamsAsset(sysParams.cdpCreatorParams.collateralAssetAuthTk),
+    iasset,
+    collateralAsset,
+  );
+
+  const stabilityPool = await findStabilityPool(lucid, sysParams, iasset);
+
+  return {
+    stabilityPoolUtxo: stabilityPool.utxo,
+    iasset: iassetOut,
+    collateralAsset: collateralAssetOut,
+    cdpCreatorUtxo: await findRandomCdpCreator(
+      lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    ),
+    interestOracleUtxo: await findInterestOracle(
+      lucid,
+      collateralAssetOut.datum.interestOracleNft,
+    ),
+    collectorUtxo: await findRandomCollector(
+      lucid,
+      sysParams.validatorHashes.collectorHash,
+    ),
+    interestCollectorUtxo: await findRandomNonAdminInterestCollector(
+      lucid,
+      sysParams.validatorHashes.interestCollectionHash,
+      fromSystemParamsAsset(sysParams.interestCollectionParams.multisigUtxoNft),
+    ),
+    govUtxo: (
+      await findGov(
+        lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      )
+    ).utxo,
+    treasuryUtxo: await findRandomTreasuryUtxoWithOnlyAda(lucid, sysParams),
+  };
+}
+
+export async function findPrice(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  asset: string,
+  collateralAsset: AssetClass,
+): Promise<Rational> {
+  const orefs = await findAllNecessaryOrefs(
+    lucid,
+    sysParams,
+    asset,
+    collateralAsset,
+  );
+
+  const priceIasset = await match(orefs.collateralAsset.datum.priceInfo)
+    .with({ OracleNft: P.select() }, async (oracleNft) => {
+      const priceOracleUtxo = matchSingle(
+        await lucid.utxosByOutRef([await findPriceOracle(lucid, oracleNft)]),
+        (_) => new Error('Expected a single price oracle UTXO'),
+      );
+      return parsePriceOracleDatum(getInlineDatumOrThrow(priceOracleUtxo))
+        .price;
+    })
+    .with({ Delisted: P.select() }, (price) => {
+      return price.price;
+    })
+    .with({ DeferredValidation: P.select() }, (_) => {
+      throw new Error('Pyth price not implemented');
+    })
+    .exhaustive();
+
+  return priceIasset;
+}
+
+export async function findInterestDatum(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  asset: string,
+  collateralAsset: AssetClass,
+): Promise<InterestOracleDatum> {
+  const orefs = await findAllNecessaryOrefs(
+    lucid,
+    sysParams,
+    asset,
+    collateralAsset,
+  );
+
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([orefs.interestOracleUtxo]),
+    (_) => new Error('Expected a single interest oracle UTXO'),
+  );
+  return parseInterestOracleDatum(getInlineDatumOrThrow(interestOracleUtxo));
+}
+
+export async function findCdpCR(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  cdp: { utxo: UTxO; datum: CDPContent },
+  slot: number,
+): Promise<number> {
+  const iassetAscii = toText(toHex(cdp.datum.iasset));
+
+  const collateralAsset = await findCollateralAsset(
+    lucid,
+    sysParams,
+    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
+    iassetAscii,
+    cdp.datum.collateralAsset,
+  );
+
+  const price = await findPrice(
+    lucid,
+    sysParams,
+    iassetAscii,
+    cdp.datum.collateralAsset,
+  );
+
+  const adjustedPrice = adjustPriceToDecimals(
+    collateralAsset.datum.extraDecimals,
+    price,
+  );
+
+  return cdpCollateralRatioPercentage(
+    slot,
+    adjustedPrice,
+    cdp.utxo,
+    cdp.datum,
+    await findInterestDatum(
+      lucid,
+      sysParams,
+      iassetAscii,
+      cdp.datum.collateralAsset,
+    ),
+    lucid.config().network!,
+  );
+}