@indigo-labs/indigo-sdk 0.2.1 → 0.2.4

package/tests/mock/assets-mock.ts

@@ -8,7 +8,7 @@ export type InitialAsset = {
       expirationTime: bigint;
     };
   };
-  initerestOracle: {
+  interestOracle: {
     tokenName: string;
     initialInterestRate: bigint;
     params: {
@@ -38,7 +38,7 @@ export const iusdInitialAssetCfg: InitialAsset = {
       expirationTime: 1_800_000n,
     },
   },
-  initerestOracle: {
+  interestOracle: {
     tokenName: 'iUSD_ORACLE',
     initialInterestRate: 1_000_000n,
     params: {

package/tests/queries/cdp-queries.ts

@@ -11,12 +11,21 @@ import {
   createScriptAddress,
   fromSystemParamsAsset,
   getRandomElement,
+  IAssetOutput,
   matchSingle,
   parseCdpDatum,
   SystemParams,
 } from '../../src';
 import { assetClassToUnit } from '../../src/utils/value-helpers';
 import { option as O, array as A, function as F } from 'fp-ts';
+import { findRandomCollector } from './collector-queries';
+import { findGov } from './governance-queries';
+import { findIAsset } from './iasset-queries';
+import { findInterestOracle } from './interest-oracle-queries';
+import { findPriceOracle } from './price-oracle-queries';
+import { findStabilityPool } from './stability-pool-queries';
+import { findRandomTreasuryUtxo } from './treasury-queries';
+import { match, P } from 'ts-pattern';
 
 export async function findAllActiveCdps(
   lucid: LucidEvolution,
@@ -142,3 +151,70 @@ export async function findRandomCdpCreator(
     }, F.identity),
   );
 }
+
+export async function findAllNecessaryOrefs(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  // ASCII encoded
+  asset: string,
+): Promise<{
+  stabilityPoolUtxo: UTxO;
+  iasset: IAssetOutput;
+  cdpCreatorUtxo: UTxO;
+  priceOracleUtxo: UTxO;
+  interestOracleUtxo: UTxO;
+  collectorUtxo: UTxO;
+  govUtxo: UTxO;
+  treasuryUtxo: UTxO;
+}> {
+  const iasset = await findIAsset(
+    lucid,
+    sysParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    asset,
+  );
+
+  const stabilityPool = await findStabilityPool(
+    lucid,
+    sysParams.validatorHashes.stabilityPoolHash,
+    fromSystemParamsAsset(sysParams.stabilityPoolParams.stabilityPoolToken),
+    asset,
+  );
+
+  return {
+    stabilityPoolUtxo: stabilityPool,
+    iasset,
+    cdpCreatorUtxo: await findRandomCdpCreator(
+      lucid,
+      sysParams.validatorHashes.cdpCreatorHash,
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    ),
+    priceOracleUtxo: await findPriceOracle(
+      lucid,
+      match(iasset.datum.price)
+        .with({ Oracle: { content: P.select() } }, (oracleNft) => oracleNft)
+        .otherwise(() => {
+          throw new Error('Expected active oracle');
+        }),
+    ),
+    interestOracleUtxo: await findInterestOracle(
+      lucid,
+      iasset.datum.interestOracleNft,
+    ),
+    collectorUtxo: await findRandomCollector(
+      lucid,
+      sysParams.validatorHashes.collectorHash,
+    ),
+    govUtxo: (
+      await findGov(
+        lucid,
+        sysParams.validatorHashes.govHash,
+        fromSystemParamsAsset(sysParams.govParams.govNFT),
+      )
+    ).utxo,
+    treasuryUtxo: await findRandomTreasuryUtxo(
+      lucid,
+      sysParams.validatorHashes.treasuryHash,
+    ),
+  };
+}

package/tests/queries/lrp-queries.ts

@@ -1,12 +1,17 @@
 import {
   Credential,
   LucidEvolution,
-  Network,
   ScriptHash,
   UTxO,
 } from '@lucid-evolution/lucid';
 import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { parseLrpDatum } from '../../src/contracts/lrp/types';
+import {
+  LRPDatum,
+  parseLrpDatum,
+  parseLrpDatumOrThrow,
+} from '../../src/contracts/lrp/types';
+import { SystemParams } from '../../src';
+import { option as O, array as A, function as F } from 'fp-ts';
 
 /**
  * Beware, this shouldn't be used in production since it queries all the UTXOs
@@ -14,12 +19,13 @@ import { parseLrpDatum } from '../../src/contracts/lrp/types';
  */
 export async function findLrp(
   lucid: LucidEvolution,
-  network: Network,
   lrpScriptHash: ScriptHash,
   owner: string,
   assetTokenName: string,
   stakeCredential?: Credential,
 ): Promise<UTxO[]> {
+  const network = lucid.config().network!;
+
   const lrpUtxos = await lucid.utxosAt(
     createScriptAddress(network, lrpScriptHash, stakeCredential),
   );
@@ -27,7 +33,7 @@ export async function findLrp(
   return lrpUtxos.filter((utxo) => {
     if (utxo.datum != null) {
       try {
-        const lrpDatum = parseLrpDatum(utxo.datum);
+        const lrpDatum = parseLrpDatumOrThrow(utxo.datum);
 
         return lrpDatum.owner == owner && lrpDatum.iasset == assetTokenName;
       } catch (_) {
@@ -37,3 +43,34 @@ export async function findLrp(
     }
   });
 }
+
+export async function findAllLrps(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  // hex encoded
+  iasset: string,
+): Promise<{ utxo: UTxO; datum: LRPDatum }[]> {
+  const lrpUtxos = await lucid.utxosAt(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.lrpHash,
+    ),
+  );
+
+  return F.pipe(
+    lrpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseLrpDatum),
+        O.flatMap((datum) => {
+          if (datum.iasset === iasset) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}

package/tests/staking.test.ts

@@ -1,6 +1,6 @@
-import { beforeEach, test } from 'vitest';
+import { beforeEach, expect, test } from 'vitest';
 import { LucidContext, runAndAwaitTx } from './test-helpers';
-import { EmulatorAccount, fromText, Lucid } from '@lucid-evolution/lucid';
+import { EmulatorAccount, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
 import { init } from './endpoints/initialize';
@@ -10,8 +10,17 @@ import { iusdInitialAssetCfg } from './mock/assets-mock';
 import {
   adjustStakingPosition,
   closeStakingPosition,
+  distributeAda,
   openStakingPosition,
 } from '../src/contracts/staking/transactions';
+import { collectorFeeTx, fromSystemParamsAsset } from '../src';
+import {
+  findAllCollectors,
+  findRandomCollector,
+} from './queries/collector-queries';
+import { findStakingManager } from '../src/contracts/staking/helpers';
+import { getValueChangeAtAddressAfterAction } from './utils';
+import { lovelacesAmt } from '@3rd-eye-labs/cardano-offchain-common';
 
 type MyContext = LucidContext<{
   admin: EmulatorAccount;
@@ -58,13 +67,7 @@ test<MyContext>('Staking - Adjust Position', async ({
   const myStakingPosition = await findStakingPosition(
     lucid,
     systemParams.validatorHashes.stakingHash,
-    {
-      currencySymbol:
-        systemParams.stakingParams.stakingToken[0].unCurrencySymbol,
-      tokenName: fromText(
-        systemParams.stakingParams.stakingToken[1].unTokenName,
-      ),
-    },
+    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
     pkh.hash,
   );
 
@@ -95,13 +98,7 @@ test<MyContext>('Staking - Close Position', async ({
   const myStakingPosition = await findStakingPosition(
     lucid,
     systemParams.validatorHashes.stakingHash,
-    {
-      currencySymbol:
-        systemParams.stakingParams.stakingToken[0].unCurrencySymbol,
-      tokenName: fromText(
-        systemParams.stakingParams.stakingToken[1].unTokenName,
-      ),
-    },
+    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
     pkh.hash,
   );
 
@@ -110,3 +107,61 @@ test<MyContext>('Staking - Close Position', async ({
     closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
   );
 });
+
+test<MyContext>('Staking - Distribute ADA to Stakers', async ({
+  lucid,
+  users,
+}: MyContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
+
+  await runAndAwaitTx(
+    lucid,
+    openStakingPosition(1_000_000n, systemParams, lucid),
+  );
+
+  const collectorOref = await findRandomCollector(
+    lucid,
+    systemParams.validatorHashes.collectorHash,
+  );
+  const tx = lucid.newTx();
+  await collectorFeeTx(100_000_000n, lucid, systemParams, tx, collectorOref);
+  await runAndAwaitTx(lucid, Promise.resolve(tx));
+
+  const collectorUtxo = (
+    await findAllCollectors(lucid, systemParams.validatorHashes.collectorHash)
+  ).find((utxo) => utxo.assets.lovelace > 100_000_000n);
+  if (!collectorUtxo) {
+    throw new Error('Expected a collector UTXO');
+  }
+
+  await runAndAwaitTx(
+    lucid,
+    distributeAda(
+      (await findStakingManager(systemParams, lucid)).utxo,
+      [collectorUtxo],
+      systemParams,
+      lucid,
+    ),
+  );
+
+  const [pkh, __] = await addrDetails(lucid);
+  const myStakingPosition = await findStakingPosition(
+    lucid,
+    systemParams.validatorHashes.stakingHash,
+    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
+    pkh.hash,
+  );
+
+  const [____, userValChange] = await getValueChangeAtAddressAfterAction(
+    lucid,
+    users.admin.address,
+    () =>
+      runAndAwaitTx(
+        lucid,
+        closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
+      ),
+  );
+
+  expect(lovelacesAmt(userValChange)).toBeGreaterThan(95_000_000n); // There is some loss due to tx fees.
+});

package/tests/indigo-test-helpers.ts

@@ -1,61 +0,0 @@
-import {
-  Assets,
-  fromText,
-  LucidEvolution,
-  Network,
-  ScriptHash,
-  toUnit,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../src/utils/lucid-utils';
-import {
-  AssetClass,
-  IAssetContent,
-  runOneShotMintTx,
-  serialiseIAssetDatum,
-} from '../src';
-
-/**
- * TODO: the NFT has to be minted using the auth policy based on execute NFT.
- * This is just a mocked setup for test purposes.
- *
- * @returns NFT of the iAsset.
- */
-export async function runCreateIAsset(
-  lucid: LucidEvolution,
-  network: Network,
-  cdpScriptHash: ScriptHash,
-  iasset: IAssetContent,
-): Promise<AssetClass> {
-  const nftTokenName = fromText('IASSET_NFT');
-  const utxos = await lucid.wallet().getUtxos();
-  const nftPolicyId = await runOneShotMintTx(lucid, {
-    referenceOutRef: {
-      txHash: utxos[0].txHash,
-      outputIdx: BigInt(utxos[0].outputIndex),
-    },
-    mintAmounts: [{ tokenName: nftTokenName, amount: 1n }],
-  });
-
-  const nftValue: Assets = { [toUnit(nftPolicyId, nftTokenName)]: 1n };
-
-  const txHash = await lucid
-    .newTx()
-    .pay.ToContract(
-      createScriptAddress(network, cdpScriptHash),
-      {
-        kind: 'inline',
-        value: serialiseIAssetDatum(iasset),
-      },
-      nftValue,
-    )
-    .complete()
-    .then((tx) => tx.sign.withWallet().complete())
-    .then((tx) => tx.submit());
-
-  await lucid.awaitTx(txHash);
-
-  return {
-    currencySymbol: nftPolicyId,
-    tokenName: nftTokenName,
-  };
-}