@indigo-labs/indigo-sdk 0.1.7 → 0.1.8

package/tests/queries/governance-queries.ts

@@ -0,0 +1,31 @@
+import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { AssetClass } from '../../src/types/generic';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { matchSingle, parseGovDatum } from '../../src';
+
+export async function findGov(
+  lucid: LucidEvolution,
+  govScriptHash: ScriptHash,
+  govNft: AssetClass,
+): Promise<UTxO> {
+  const govUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network, govScriptHash),
+    assetClassToUnit(govNft),
+  );
+
+  return matchSingle(
+    govUtxos.filter((utxo) => {
+      if (utxo.datum != null) {
+        try {
+          parseGovDatum(utxo.datum);
+          return true; // TODO: implement Gov Datum
+        } catch (_) {
+          // when incompatible datum
+          return false;
+        }
+      }
+    }),
+    (res) => new Error('Expected a single Gov UTXO.: ' + JSON.stringify(res)),
+  );
+}

package/tests/queries/iasset-queries.ts

@@ -0,0 +1,39 @@
+import {
+  fromText,
+  LucidEvolution,
+  ScriptHash,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { AssetClass } from '../../src/types/generic';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { matchSingle, parseIAssetDatum } from '../../src';
+
+export async function findIAsset(
+  lucid: LucidEvolution,
+  iassetScriptHash: ScriptHash,
+  iassetNft: AssetClass,
+  iassetName: string,
+): Promise<UTxO> {
+  const iassetUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network, iassetScriptHash),
+    assetClassToUnit(iassetNft),
+  );
+
+  return matchSingle(
+    iassetUtxos.filter((utxo) => {
+      if (utxo.datum != null) {
+        try {
+          const iassetDatum = parseIAssetDatum(utxo.datum);
+
+          return iassetDatum.assetName == fromText(iassetName);
+        } catch (_) {
+          // when incompatible datum
+          return false;
+        }
+      }
+    }),
+    (res) =>
+      new Error('Expected a single IAsset UTXO.: ' + JSON.stringify(res)),
+  );
+}

package/tests/queries/interest-oracle-queries.ts

@@ -0,0 +1,13 @@
+import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
+import { AssetClass } from '../../src/types/generic';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { InterestOracleDatum, parseInterestOracleDatum } from '../../src';
+
+export async function findInterestOracle(
+  lucid: LucidEvolution,
+  interestNft: AssetClass,
+): Promise<[UTxO, InterestOracleDatum]> {
+  const interestUtxo = await lucid.utxoByUnit(assetClassToUnit(interestNft));
+  if (!interestUtxo.datum) throw new Error('No interest oracle utxo found');
+  return [interestUtxo, parseInterestOracleDatum(interestUtxo.datum)];
+}

package/tests/queries/lrp-queries.ts

@@ -0,0 +1,39 @@
+import {
+  Credential,
+  LucidEvolution,
+  Network,
+  ScriptHash,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { parseLrpDatum } from '../../src/types/indigo/lrp';
+
+/**
+ * Beware, this shouldn't be used in production since it queries all the UTXOs
+ * at an address and does the filtering in this function.
+ */
+export async function findLrp(
+  lucid: LucidEvolution,
+  network: Network,
+  lrpScriptHash: ScriptHash,
+  owner: string,
+  assetTokenName: string,
+  stakeCredential?: Credential,
+): Promise<UTxO[]> {
+  const lrpUtxos = await lucid.utxosAt(
+    createScriptAddress(network, lrpScriptHash, stakeCredential),
+  );
+
+  return lrpUtxos.filter((utxo) => {
+    if (utxo.datum != null) {
+      try {
+        const lrpDatum = parseLrpDatum(utxo.datum);
+
+        return lrpDatum.owner == owner && lrpDatum.iasset == assetTokenName;
+      } catch (_) {
+        // when incompatible datum
+        return false;
+      }
+    }
+  });
+}

package/tests/queries/price-oracle-queries.ts

@@ -0,0 +1,27 @@
+import {
+  LucidEvolution,
+  Network,
+  OutRef,
+  ScriptHash,
+  toUnit,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress, matchSingle, OracleAssetNft } from '../../src';
+
+export async function findPriceOracle(
+  lucid: LucidEvolution,
+  network: Network,
+  oracleScriptHash: ScriptHash,
+  oracleNft: OracleAssetNft,
+): Promise<OutRef> {
+  return matchSingle(
+    await lucid.utxosAtWithUnit(
+      createScriptAddress(network, oracleScriptHash),
+      toUnit(
+        oracleNft.oracleNft.asset.currencySymbol,
+        oracleNft.oracleNft.asset.tokenName,
+      ),
+    ),
+    (res) =>
+      new Error('Expected a single Oracle UTXO.: ' + JSON.stringify(res)),
+  );
+}

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

@@ -0,0 +1,75 @@
+import {
+  fromText,
+  LucidEvolution,
+  ScriptHash,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { AssetClass } from '../../src/types/generic';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import {
+  matchSingle,
+  parseAccountDatum,
+  parseStabilityPoolDatum,
+} from '../../src';
+
+export async function findStabilityPool(
+  lucid: LucidEvolution,
+  stabilityPoolHash: ScriptHash,
+  stabilityPoolToken: AssetClass,
+  asset: string,
+): Promise<UTxO> {
+  const stakingUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network, stabilityPoolHash),
+    assetClassToUnit(stabilityPoolToken),
+  );
+
+  return matchSingle(
+    stakingUtxos.filter((utxo) => {
+      if (utxo.datum != null) {
+        try {
+          const stabilityPoolDatum = parseStabilityPoolDatum(utxo.datum);
+
+          return stabilityPoolDatum.asset == fromText(asset);
+        } catch (_) {
+          // when incompatible datum
+          return false;
+        }
+      }
+    }),
+    (res) =>
+      new Error(
+        'Expected a single Stability Pool UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}
+
+export async function findStabilityPoolAccount(
+  lucid: LucidEvolution,
+  stabilityPoolHash: ScriptHash,
+  owner: string,
+  asset: string,
+): Promise<UTxO> {
+  const accountUtxos = await lucid.utxosAt(
+    createScriptAddress(lucid.config().network, stabilityPoolHash),
+  );
+
+  return matchSingle(
+    accountUtxos.filter((utxo) => {
+      if (utxo.datum != null) {
+        try {
+          const accountDatum = parseAccountDatum(utxo.datum);
+
+          return (
+            accountDatum.asset == fromText(asset) && accountDatum.owner == owner
+          );
+        } catch (_) {
+          // when incompatible datum
+          return false;
+        }
+      }
+    }),
+    (res) =>
+      new Error('Expected a single Account UTXO.: ' + JSON.stringify(res)),
+  );
+}

package/tests/queries/staking-queries.ts

@@ -0,0 +1,43 @@
+import {
+  LucidEvolution,
+  Network,
+  OutRef,
+  ScriptHash,
+} from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { AssetClass } from '../../src/types/generic';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { matchSingle } from '../../src';
+import { parseStakingPositionDatum } from '../../src/types/indigo/staking';
+
+export async function findStakingPosition(
+  lucid: LucidEvolution,
+  network: Network,
+  stakingScriptHash: ScriptHash,
+  stakingPositionNft: AssetClass,
+  owner: string,
+): Promise<OutRef> {
+  const stakingUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(network, stakingScriptHash),
+    assetClassToUnit(stakingPositionNft),
+  );
+
+  return matchSingle(
+    stakingUtxos.filter((utxo) => {
+      if (utxo.datum != null) {
+        try {
+          const stakingDatum = parseStakingPositionDatum(utxo.datum);
+
+          return stakingDatum.owner == owner;
+        } catch (_) {
+          // when incompatible datum
+          return false;
+        }
+      }
+    }),
+    (res) =>
+      new Error(
+        'Expected a single Staking Position UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}

package/tests/stability-pool.test.ts

@@ -0,0 +1,364 @@
+import { beforeEach, test, afterEach } from 'vitest';
+import { LucidContext, runAndAwaitTx } from './test-helpers';
+import { 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 {
+  findStabilityPool,
+  findStabilityPoolAccount,
+} from './queries/stability-pool-queries';
+import { findIAsset } from './queries/iasset-queries';
+import { findGov } from './queries/governance-queries';
+
+let originalDateNow: () => number;
+
+beforeEach<LucidContext>(async (context: LucidContext) => {
+  context.users = {
+    admin: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+    user: generateEmulatorAccount({
+      lovelace: BigInt(100_000_000_000_000),
+    }),
+  };
+
+  context.emulator = new Emulator([context.users.admin, context.users.user]);
+
+  context.lucid = await Lucid(context.emulator, 'Custom');
+
+  originalDateNow = Date.now;
+  Date.now = () => context.emulator.now();
+});
+
+afterEach(() => {
+  Date.now = originalDateNow;
+});
+
+test<LucidContext>('Stability Pool - Create Account', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  const stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});
+
+test<LucidContext>('Stability Pool - Adjust Account', async ({
+  lucid,
+  users,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid);
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  let stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  let accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.adjustAccount(
+      'iUSD',
+      10n,
+      accountUtxo,
+      systemParams,
+      lucid,
+    ),
+  );
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});
+
+test<LucidContext>('Stability Pool - Close Account', async ({
+  lucid,
+  users,
+  emulator,
+}: LucidContext) => {
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+  const systemParams = await init(lucid, emulator.now());
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+  const [pkh, _] = await addrDetails(lucid);
+
+  await runAndAwaitTx(
+    lucid,
+    CDPContract.openPosition('iUSD', 1_000_000_000n, 20n, systemParams, lucid),
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.createAccount('iUSD', 10n, systemParams, lucid),
+  );
+
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  let stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  let accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  const assetUtxo = await findIAsset(
+    lucid,
+    systemParams.validatorHashes.cdpHash,
+    {
+      currencySymbol:
+        systemParams.cdpParams.iAssetAuthToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.cdpParams.iAssetAuthToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  const govUtxo = await findGov(lucid, systemParams.validatorHashes.govHash, {
+    currencySymbol: systemParams.govParams.govNFT[0].unCurrencySymbol,
+    tokenName: fromText(systemParams.govParams.govNFT[1].unTokenName),
+  });
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+
+  lucid.selectWallet.fromSeed(users.user.seedPhrase);
+
+  stabilityPoolUtxo = await findStabilityPool(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    {
+      currencySymbol:
+        systemParams.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol,
+      tokenName: fromText(
+        systemParams.stabilityPoolParams.stabilityPoolToken[1].unTokenName,
+      ),
+    },
+    'iUSD',
+  );
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.closeAccount(accountUtxo, systemParams, lucid),
+  );
+  lucid.selectWallet.fromSeed(users.admin.seedPhrase);
+
+  accountUtxo = await findStabilityPoolAccount(
+    lucid,
+    systemParams.validatorHashes.stabilityPoolHash,
+    pkh.hash,
+    'iUSD',
+  );
+
+  await runAndAwaitTx(
+    lucid,
+    StabilityPoolContract.processRequest(
+      'iUSD',
+      stabilityPoolUtxo,
+      accountUtxo,
+      govUtxo,
+      assetUtxo,
+      undefined,
+      systemParams,
+      lucid,
+    ),
+  );
+});