@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/queries/stability-pool-queries.ts

@@ -1,43 +1,51 @@
+import { fromText, LucidEvolution, toHex, UTxO } from '@lucid-evolution/lucid';
 import {
-  fromText,
-  LucidEvolution,
-  ScriptHash,
-  toHex,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { matchSingle } from '../../src';
+  fromSystemParamsAsset,
+  matchSingle,
+  mkStabilityPoolAddr,
+  SystemParams,
+} from '../../src';
 import {
+  AccountContent,
   parseAccountDatum,
+  parseSnapshotEpochToScaleToSumDatum,
   parseStabilityPoolDatum,
+  SnapshotEpochToScaleToSumContent,
+  StabilityPoolContent,
 } from '../../src/contracts/stability-pool/types-new';
+import { assetClassToUnit } from '@3rd-eye-labs/cardano-offchain-common';
+import { option as O, array as A, function as F } from 'fp-ts';
 
 export async function findStabilityPool(
   lucid: LucidEvolution,
-  stabilityPoolHash: ScriptHash,
-  stabilityPoolToken: AssetClass,
+  sysParams: SystemParams,
   asset: string,
-): Promise<UTxO> {
-  const stakingUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, stabilityPoolHash),
-    assetClassToUnit(stabilityPoolToken),
+): Promise<{ utxo: UTxO; datum: StabilityPoolContent }> {
+  // We need to consider both with staking credential and without.
+  const spUtxos = await lucid.utxosAtWithUnit(
+    { hash: sysParams.validatorHashes.stabilityPoolHash, type: 'Script' },
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.stabilityPoolParams.stabilityPoolToken),
+    ),
   );
 
   return matchSingle(
-    stakingUtxos.filter((utxo) => {
-      if (utxo.datum != null) {
-        try {
-          const stabilityPoolDatum = parseStabilityPoolDatum(utxo.datum);
-
-          return toHex(stabilityPoolDatum.asset) == fromText(asset);
-        } catch (_) {
-          // when incompatible datum
-          return false;
-        }
-      }
-    }),
+    F.pipe(
+      spUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseStabilityPoolDatum),
+          O.flatMap((datum) => {
+            if (toHex(datum.iasset) == fromText(asset)) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
     (res) =>
       new Error(
         'Expected a single Stability Pool UTXO.: ' + JSON.stringify(res),
@@ -47,31 +55,70 @@ export async function findStabilityPool(
 
 export async function findStabilityPoolAccount(
   lucid: LucidEvolution,
-  stabilityPoolHash: ScriptHash,
+  sysParams: SystemParams,
   owner: string,
   asset: string,
-): Promise<UTxO> {
-  const accountUtxos = await lucid.utxosAt(
-    createScriptAddress(lucid.config().network!, stabilityPoolHash),
-  );
+): Promise<{ utxo: UTxO; datum: AccountContent }> {
+  // We need to consider both with staking credential and without.
+  const spUtxos = await lucid.utxosAt({
+    hash: sysParams.validatorHashes.stabilityPoolHash,
+    type: 'Script',
+  });
 
   return matchSingle(
-    accountUtxos.filter((utxo) => {
-      if (utxo.datum != null) {
-        try {
-          const accountDatum = parseAccountDatum(utxo.datum);
-
-          return (
-            toHex(accountDatum.asset) == fromText(asset) &&
-            toHex(accountDatum.owner) == owner
-          );
-        } catch (_) {
-          // when incompatible datum
-          return false;
-        }
-      }
-    }),
+    F.pipe(
+      spUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseAccountDatum),
+          O.flatMap((datum) => {
+            if (
+              toHex(datum.iasset) == fromText(asset) &&
+              toHex(datum.owner) == owner
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
     (res) =>
       new Error('Expected a single Account UTXO.: ' + JSON.stringify(res)),
   );
 }
+
+export async function findE2s2sSnapshots(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  asset: string,
+): Promise<{ utxo: UTxO; datum: SnapshotEpochToScaleToSumContent }[]> {
+  // No need to query the ones without stake cred, e2s2s will always have stake cred based on script params.
+  const spUtxos = await lucid.utxosAtWithUnit(
+    mkStabilityPoolAddr(lucid, sysParams),
+    assetClassToUnit(
+      fromSystemParamsAsset(
+        sysParams.stabilityPoolParams.snapshotEpochToScaleToSumToken,
+      ),
+    ),
+  );
+
+  return F.pipe(
+    spUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseSnapshotEpochToScaleToSumDatum),
+        O.flatMap((datum) => {
+          if (toHex(datum.iasset) == fromText(asset)) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}

package/tests/queries/staking-queries.ts

@@ -5,14 +5,16 @@ import {
   UTxO,
 } from '@lucid-evolution/lucid';
 import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
 import { matchSingle } from '../../src';
 import { option as O, array as A, function as F } from 'fp-ts';
 import {
   parseStakingPosition,
   StakingPosition,
 } from '../../src/contracts/staking/types-new';
+import {
+  AssetClass,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function findStakingPosition(
   lucid: LucidEvolution,

package/tests/queries/treasury-queries.ts

@@ -1,13 +1,60 @@
-import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress, getRandomElement } from '../../src';
+import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
+import { getRandomElement, SystemParams } from '../../src';
 import { option as O, function as F } from 'fp-ts';
+import {
+  AssetClass,
+  assetClassToUnit,
+} from '@3rd-eye-labs/cardano-offchain-common';
 
 export async function findRandomTreasuryUtxo(
   lucid: LucidEvolution,
-  treasuryScriptHash: ScriptHash,
+  sysParams: SystemParams,
 ): Promise<UTxO> {
-  const treasuryUtxos = await lucid.utxosAt(
-    createScriptAddress(lucid.config().network!, treasuryScriptHash),
+  // We need to consider both with staking credential and without.
+  const treasuryUtxos = await lucid.utxosAt({
+    hash: sysParams.validatorHashes.treasuryHash,
+    type: 'Script',
+  });
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(treasuryUtxos)),
+    O.match(() => {
+      throw new Error('Expected some treasury UTXOs.');
+    }, F.identity),
+  );
+}
+
+export async function findRandomTreasuryUtxoWithOnlyAda(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<UTxO> {
+  // We need to consider both with staking credential and without.
+  const treasuryUtxos = await lucid.utxosAt({
+    hash: sysParams.validatorHashes.treasuryHash,
+    type: 'Script',
+  });
+
+  const adaOnlyTreasuryUtxos = treasuryUtxos.filter(
+    (utxo) => Object.keys(utxo.assets).length == 1,
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(adaOnlyTreasuryUtxos)),
+    O.match(() => {
+      throw new Error('Expected some treasury UTXOs.');
+    }, F.identity),
+  );
+}
+
+export async function findRandomTreasuryUtxoWithAsset(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  asset: AssetClass,
+): Promise<UTxO> {
+  // We need to consider both with staking credential and without.
+  const treasuryUtxos = await lucid.utxosAtWithUnit(
+    { hash: sysParams.validatorHashes.treasuryHash, type: 'Script' },
+    assetClassToUnit(asset),
   );
 
   return F.pipe(
@@ -17,3 +64,31 @@ export async function findRandomTreasuryUtxo(
     }, F.identity),
   );
 }
+
+export async function findAllTreasuryUtxos(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<UTxO[]> {
+  // We need to consider both with staking credential and without.
+  return lucid.utxosAt({
+    type: 'Script',
+    hash: sysParams.validatorHashes.treasuryHash,
+  });
+}
+
+export async function findAllTreasuryUtxosWithNonAdaAsset(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<UTxO[]> {
+  // We need to consider both with staking credential and without.
+  const treasuryUtxos = await lucid.utxosAt({
+    hash: sysParams.validatorHashes.treasuryHash,
+    type: 'Script',
+  });
+
+  const treasuryUtxosWithNonAdaAsset = treasuryUtxos.filter(
+    (utxo) => Object.keys(utxo.assets).length !== 1,
+  );
+
+  return treasuryUtxosWithNonAdaAsset;
+}

package/tests/rob/actions.ts

@@ -0,0 +1,58 @@
+import { fromText, TxBuilder } from '@lucid-evolution/lucid';
+import { LucidContext } from '../test-helpers';
+import { fromSystemParamsAsset, redeemRob, SystemParams } from '../../src';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import { RobOutput } from '../../src/contracts/rob/types-new';
+import { findCollateralAsset, findIAsset } from '../queries/iasset-queries';
+import { findPriceOracleFromCollateralAsset } from '../cdp/cdp-queries';
+
+export async function runRedeemRob(
+  context: LucidContext,
+  sysParams: SystemParams,
+  redemptionRobsData: [RobOutput, bigint][],
+  iasset: string,
+  collateralAsset: AssetClass,
+  currentSlot: number,
+  pythMessage?: string,
+): Promise<TxBuilder> {
+  if (redemptionRobsData.length === 0) throw new Error('No ROBs to redeem');
+
+  const collateral = await findCollateralAsset(
+    context.lucid,
+    sysParams,
+    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
+    iasset,
+    collateralAsset,
+  );
+
+  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
+    context.lucid,
+    collateral,
+  );
+
+  const iassetOut = await findIAsset(
+    context.lucid,
+    sysParams.validatorHashes.iassetHash,
+    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    iasset,
+  );
+
+  const pythStateOutRef = pythMessage
+    ? await context.lucid.utxoByUnit(
+        sysParams.pythConfig.pythStateAssetClass[0].unCurrencySymbol +
+          fromText('Pyth State'),
+      )
+    : undefined;
+
+  return redeemRob(
+    redemptionRobsData.map(([out, amt]) => [out.utxo, amt]),
+    priceOracleUtxo,
+    iassetOut.utxo,
+    collateral.utxo,
+    context.lucid,
+    sysParams,
+    currentSlot,
+    pythMessage,
+    pythStateOutRef,
+  );
+}