@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/cdp/cdp-queries.ts

@@ -1,423 +0,0 @@
-import {
-  Credential,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  ScriptHash,
-  toHex,
-  toText,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  addrDetails,
-  adjustPriceToDecimals,
-  cdpCollateralRatioPercentage,
-  createScriptAddress,
-  findStabilityPool,
-  fromSystemParamsAsset,
-  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,
-  getRandomElement,
-} 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 { 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 '../../src/contracts/treasury/queries';
-import { parsePriceOracleDatum } from '../../src/contracts/price-oracle/types-new';
-import {
-  CollateralAssetOutput,
-  IAssetOutput,
-} from '../../src/contracts/iasset/types';
-import { findRandomNonAdminInterestCollector } from '../../src/contracts/interest-collection/queries';
-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 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,
-    fromHex(fromText(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,
-    ),
-    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 },
-): 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(
-    BigInt(lucid.slotToUnixTime(lucid.currentSlot())),
-    adjustedPrice,
-    cdp.utxo.assets,
-    cdp.datum,
-    await findInterestDatum(
-      lucid,
-      sysParams,
-      iassetAscii,
-      cdp.datum.collateralAsset,
-    ),
-  );
-}