@indigo-labs/indigo-sdk 0.1.27 → 0.2.0

package/tests/stability-pool.test.ts

@@ -1,20 +1,39 @@
 import { beforeEach, test, afterEach } from 'vitest';
 import { LucidContext, runAndAwaitTx } from './test-helpers';
-import { fromText, Lucid } from '@lucid-evolution/lucid';
+import { EmulatorAccount, fromText, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
 import { init } from './endpoints/initialize';
-import { addrDetails, CDPContract, StabilityPoolContract } from '../src';
+import {
+  addrDetails,
+  adjustSpAccount,
+  closeSpAccount,
+  createSpAccount,
+  fromSystemParamsAsset,
+  openCdp,
+  processSpRequest,
+} from '../src';
 import {
   findStabilityPool,
   findStabilityPoolAccount,
 } from './queries/stability-pool-queries';
 import { findIAsset } from './queries/iasset-queries';
 import { findGov } from './queries/governance-queries';
+import { findRandomCdpCreator } from './queries/cdp-queries';
+import { findPriceOracle } from './queries/price-oracle-queries';
+import { match, P } from 'ts-pattern';
+import { findInterestOracle } from './queries/interest-oracle-queries';
+import { findRandomCollector } from './queries/collector-queries';
+import { iusdInitialAssetCfg } from './mock/assets-mock';
 
 let originalDateNow: () => number;
 
-beforeEach<LucidContext>(async (context: LucidContext) => {
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+  user: EmulatorAccount;
+}>;
+
+beforeEach<MyContext>(async (context: MyContext) => {
   context.users = {
     admin: generateEmulatorAccount({
       lovelace: BigInt(100_000_000_000_000),
@@ -36,23 +55,48 @@ afterEach(() => {
   Date.now = originalDateNow;
 });
 
-test<LucidContext>('Stability Pool - Create Account', async ({
+test<MyContext>('Stability Pool - Create Account', async ({
   lucid,
   users,
   emulator,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid);
+  const [systemParams, [iusdInfo]] = await init(lucid, [iusdInitialAssetCfg]);
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
   const [pkh, _] = await addrDetails(lucid);
 
+  const iasset = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(systemParams.cdpParams.iAssetAuthToken),
+    iusdInfo.iassetTokenNameAscii,
+  );
+
   await runAndAwaitTx(
     lucid,
-    CDPContract.openPosition(
-      'iUSD',
+    openCdp(
       1_000_000_000n,
       20n,
       systemParams,
+      await findRandomCdpCreator(
+        lucid,
+        systemParams.validatorHashes.cdpCreatorHash,
+        fromSystemParamsAsset(systemParams.cdpCreatorParams.cdpCreatorNft),
+      ),
+      iasset.utxo,
+      await findPriceOracle(
+        lucid,
+        match(iasset.datum.price)
+          .with({ Oracle: { content: P.select() } }, (oracleNft) => oracleNft)
+          .otherwise(() => {
+            throw new Error('Expected active oracle');
+          }),
+      ),
+      await findInterestOracle(lucid, iasset.datum.interestOracleNft),
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
       lucid,
       emulator.slot,
     ),
@@ -60,7 +104,7 @@ test<LucidContext>('Stability Pool - Create Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+    createSpAccount(iusdInfo.iassetTokenNameAscii, 10n, systemParams, lucid),
   );
 
   const stabilityPoolUtxo = await findStabilityPool(
@@ -73,14 +117,14 @@ test<LucidContext>('Stability Pool - Create Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const assetUtxo = await findIAsset(
@@ -93,7 +137,7 @@ test<LucidContext>('Stability Pool - Create Account', async ({
         systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
@@ -105,36 +149,65 @@ test<LucidContext>('Stability Pool - Create Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 });
 
-test<LucidContext>('Stability Pool - Adjust Account', async ({
+test<MyContext>('Stability Pool - Adjust Account', async ({
   lucid,
   users,
   emulator,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid);
+  const [systemParams, [iusdInfo]] = await init(lucid, [iusdInitialAssetCfg]);
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
   const [pkh, _] = await addrDetails(lucid);
 
+  const iasset = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(systemParams.cdpParams.iAssetAuthToken),
+    iusdInfo.iassetTokenNameAscii,
+  );
+
   await runAndAwaitTx(
     lucid,
-    CDPContract.openPosition(
-      'iUSD',
+    openCdp(
       1_000_000_000n,
       20n,
       systemParams,
+      await findRandomCdpCreator(
+        lucid,
+        systemParams.validatorHashes.cdpCreatorHash,
+        fromSystemParamsAsset(systemParams.cdpCreatorParams.cdpCreatorNft),
+      ),
+      iasset.utxo,
+      await findPriceOracle(
+        lucid,
+        match(iasset.datum.price)
+          .with({ Oracle: { content: P.select() } }, (oracleNft) => oracleNft)
+          .otherwise(() => {
+            throw new Error('Expected active oracle');
+          }),
+      ),
+      await findInterestOracle(lucid, iasset.datum.interestOracleNft),
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
       lucid,
       emulator.slot,
     ),
@@ -142,7 +215,7 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+    createSpAccount(iusdInfo.iassetTokenNameAscii, 10n, systemParams, lucid),
   );
 
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
@@ -157,14 +230,14 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   let accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const assetUtxo = await findIAsset(
@@ -177,7 +250,7 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
         systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
@@ -187,15 +260,19 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 
@@ -211,20 +288,20 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.adjustAccount(
-      'iUSD',
+    adjustSpAccount(
+      iusdInfo.iassetTokenNameAscii,
       10n,
       accountUtxo,
       systemParams,
@@ -237,20 +314,24 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 
@@ -267,20 +348,20 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.adjustAccount(
-      'iUSD',
+    adjustSpAccount(
+      iusdInfo.iassetTokenNameAscii,
       -10n,
       accountUtxo,
       systemParams,
@@ -293,41 +374,70 @@ test<LucidContext>('Stability Pool - Adjust Account', async ({
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 });
 
-test<LucidContext>('Stability Pool - Close Account', async ({
+test<MyContext>('Stability Pool - Close Account', async ({
   lucid,
   users,
   emulator,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid, emulator.now());
+  const [systemParams, [iusdInfo]] = await init(lucid, [iusdInitialAssetCfg]);
   lucid.selectWallet.fromSeed(users.user.seedPhrase);
   const [pkh, _] = await addrDetails(lucid);
 
+  const iasset = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(systemParams.cdpParams.iAssetAuthToken),
+    iusdInfo.iassetTokenNameAscii,
+  );
+
   await runAndAwaitTx(
     lucid,
-    CDPContract.openPosition(
-      'iUSD',
+    openCdp(
       1_000_000_000n,
       20n,
       systemParams,
+      await findRandomCdpCreator(
+        lucid,
+        systemParams.validatorHashes.cdpCreatorHash,
+        fromSystemParamsAsset(systemParams.cdpCreatorParams.cdpCreatorNft),
+      ),
+      iasset.utxo,
+      await findPriceOracle(
+        lucid,
+        match(iasset.datum.price)
+          .with({ Oracle: { content: P.select() } }, (oracleNft) => oracleNft)
+          .otherwise(() => {
+            throw new Error('Expected active oracle');
+          }),
+      ),
+      await findInterestOracle(lucid, iasset.datum.interestOracleNft),
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
       lucid,
       emulator.slot,
     ),
@@ -335,7 +445,7 @@ test<LucidContext>('Stability Pool - Close Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+    createSpAccount(iusdInfo.iassetTokenNameAscii, 10n, systemParams, lucid),
   );
 
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
@@ -350,14 +460,14 @@ test<LucidContext>('Stability Pool - Close Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   let accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const assetUtxo = await findIAsset(
@@ -370,7 +480,7 @@ test<LucidContext>('Stability Pool - Close Account', async ({
         systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
@@ -380,15 +490,19 @@ test<LucidContext>('Stability Pool - Close Account', async ({
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 
@@ -404,40 +518,41 @@ test<LucidContext>('Stability Pool - Close Account', async ({
         systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
       ),
     },
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
-  await runAndAwaitTx(
-    lucid,
-    StabilityPoolContract.closeAccount(accountUtxo, systemParams, lucid),
-  );
+  await runAndAwaitTx(lucid, closeSpAccount(accountUtxo, systemParams, lucid));
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
 
   accountUtxo = await findStabilityPoolAccount(
     lucid,
     systemParams.validatorHashes.stabilityPoolHash,
     pkh.hash,
-    'iUSD',
+    iusdInfo.iassetTokenNameAscii,
   );
 
   await runAndAwaitTx(
     lucid,
-    StabilityPoolContract.processRequest(
-      'iUSD',
+    processSpRequest(
+      iusdInfo.iassetTokenNameAscii,
       stabilityPoolUtxo,
       accountUtxo,
-      govUtxo,
-      assetUtxo,
+      govUtxo.utxo,
+      assetUtxo.utxo,
       undefined,
       systemParams,
       lucid,
+      await findRandomCollector(
+        lucid,
+        systemParams.validatorHashes.collectorHash,
+      ),
     ),
   );
 });

package/tests/staking.test.ts

@@ -1,14 +1,23 @@
 import { beforeEach, test } from 'vitest';
 import { LucidContext, runAndAwaitTx } from './test-helpers';
-import { fromText, Lucid } from '@lucid-evolution/lucid';
+import { EmulatorAccount, fromText, Lucid } from '@lucid-evolution/lucid';
 import { Emulator } from '@lucid-evolution/lucid';
 import { generateEmulatorAccount } from '@lucid-evolution/lucid';
-import { StakingContract } from '../src/contracts/staking';
 import { init } from './endpoints/initialize';
-import { addrDetails } from '../src/helpers/lucid-utils';
+import { addrDetails } from '../src/utils/lucid-utils';
 import { findStakingPosition } from './queries/staking-queries';
+import { iusdInitialAssetCfg } from './mock/assets-mock';
+import {
+  adjustStakingPosition,
+  closeStakingPosition,
+  openStakingPosition,
+} from '../src/contracts/staking/transactions';
 
-beforeEach<LucidContext>(async (context: LucidContext) => {
+type MyContext = LucidContext<{
+  admin: EmulatorAccount;
+}>;
+
+beforeEach<MyContext>(async (context: MyContext) => {
   context.users = {
     admin: generateEmulatorAccount({
       lovelace: BigInt(100_000_000_000_000),
@@ -20,35 +29,34 @@ beforeEach<LucidContext>(async (context: LucidContext) => {
   context.lucid = await Lucid(context.emulator, 'Custom');
 });
 
-test<LucidContext>('Staking - Create Position', async ({
+test<MyContext>('Staking - Create Position', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid);
+  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
 
   await runAndAwaitTx(
     lucid,
-    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+    openStakingPosition(1_000_000n, systemParams, lucid),
   );
 });
 
-test<LucidContext>('Staking - Adjust Position', async ({
+test<MyContext>('Staking - Adjust Position', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid);
+  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
 
   await runAndAwaitTx(
     lucid,
-    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+    openStakingPosition(1_000_000n, systemParams, lucid),
   );
 
-  const [pkh, _] = await addrDetails(lucid);
+  const [pkh, __] = await addrDetails(lucid);
   const myStakingPosition = await findStakingPosition(
     lucid,
-    lucid.config().network,
     systemParams.validatorHashes.stakingHash,
     {
       currencySymbol:
@@ -62,8 +70,8 @@ test<LucidContext>('Staking - Adjust Position', async ({
 
   await runAndAwaitTx(
     lucid,
-    StakingContract.adjustPosition(
-      myStakingPosition,
+    adjustStakingPosition(
+      myStakingPosition.utxo,
       1_000_000n,
       systemParams,
       lucid,
@@ -71,22 +79,21 @@ test<LucidContext>('Staking - Adjust Position', async ({
   );
 });
 
-test<LucidContext>('Staking - Close Position', async ({
+test<MyContext>('Staking - Close Position', async ({
   lucid,
   users,
-}: LucidContext) => {
+}: MyContext) => {
   lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-  const systemParams = await init(lucid);
+  const [systemParams, _] = await init(lucid, [iusdInitialAssetCfg]);
 
   await runAndAwaitTx(
     lucid,
-    StakingContract.openPosition(1_000_000n, systemParams, lucid),
+    openStakingPosition(1_000_000n, systemParams, lucid),
   );
 
-  const [pkh, _] = await addrDetails(lucid);
+  const [pkh, __] = await addrDetails(lucid);
   const myStakingPosition = await findStakingPosition(
     lucid,
-    lucid.config().network,
     systemParams.validatorHashes.stakingHash,
     {
       currencySymbol:
@@ -100,6 +107,6 @@ test<LucidContext>('Staking - Close Position', async ({
 
   await runAndAwaitTx(
     lucid,
-    StakingContract.closePosition(myStakingPosition, systemParams, lucid),
+    closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
   );
 });

package/tests/test-helpers.ts

@@ -5,9 +5,9 @@ import {
   TxBuilder,
 } from '@lucid-evolution/lucid';
 
-export type LucidContext = {
+export type LucidContext<T extends Record<string, EmulatorAccount>> = {
   lucid: LucidEvolution;
-  users: { [key: string]: EmulatorAccount };
+  users: T;
   emulator: Emulator;
 };
 
@@ -36,3 +36,12 @@ export async function runAndAwaitTxBuilder(
   await lucid.awaitTx(txHash);
   return txHash;
 }
+
+export async function repeat(
+  times: number,
+  action: () => Promise<void>,
+): Promise<void> {
+  for (let i = 0; i < times; i++) {
+    await action();
+  }
+}

package/tests/utils/asserts.ts

@@ -0,0 +1,13 @@
+import { assert, expect } from 'vitest';
+
+export function assertValueInRange<T extends number | bigint>(
+  val: T,
+  bounds: { min: T; max: T },
+): void {
+  assert(bounds.max > bounds.min, 'Bounds are incorrectly configured.');
+
+  expect(
+    bounds.min <= val && val <= bounds.max,
+    `${val} not in range [${bounds.min}, ${bounds.max}]`,
+  ).toBeTruthy();
+}