@indigo-labs/indigo-sdk 0.1.2 → 0.1.3

package/tests/lrp.test.ts

@@ -0,0 +1,149 @@
+import { describe, it } from 'vitest';
+import {
+  Emulator,
+  fromText,
+  generateEmulatorAccount,
+  Lucid,
+  Network,
+  validatorToScriptHash,
+} from '@lucid-evolution/lucid';
+import { LRPParams } from '../src/types/indigo/lrp';
+import { mkLrpValidator } from '../src/scripts/lrp-validator';
+import { runCreateScriptRefTx } from '../src/helpers/helper-txs';
+import { runOneShotMintTx } from '../src/contracts/one-shot';
+import { cancelLrp, openLrp } from '../src/contracts/lrp';
+import { findLrp } from './queries/lrp-queries';
+import { addrDetails } from '../src/helpers/lucid-utils';
+import { runAndAwaitTx } from './test-helpers';
+import { matchSingle } from '../src/helpers/helpers';
+import { runCreateIAsset, runStartPriceOracle } from './indigo-test-helpers';
+import { mkPriceOracleValidator } from '../src/scripts/price-oracle-validator';
+import { AssetClass, PriceOracleParams } from '../src';
+import { alwaysFailValidator } from '../src/scripts/always-fail-validator';
+import { OCD_ONE, OCD_ZERO } from '../src/types/on-chain-decimal';
+
+describe('LRP', () => {
+  it('case 1', async () => {
+    const network: Network = 'Custom';
+    const account1 = generateEmulatorAccount({
+      lovelace: 80_000_000_000n, // 80,000 ADA
+    });
+    const emulator = new Emulator([account1]);
+
+    const lucid = await Lucid(emulator, network);
+    lucid.selectWallet.fromSeed(account1.seedPhrase);
+
+    const iassetTokenName = fromText('TEST_IBTC');
+    const utxos = await lucid.wallet().getUtxos();
+    const iassetPolicyId = await runOneShotMintTx(lucid, {
+      referenceOutRef: {
+        txHash: utxos[0].txHash,
+        outputIdx: BigInt(utxos[0].outputIndex),
+      },
+      mintAmounts: [{ tokenName: iassetTokenName, amount: 10_000_000n }],
+    });
+
+    const [ownPkh, _] = await addrDetails(lucid);
+
+    const priceOracleParams: PriceOracleParams = {
+      owner: ownPkh.hash,
+      // 1 minute
+      biasTime: 1n * 60n * 1000n,
+      // 10 minutes
+      expiration: 10n * 60n * 1000n,
+    };
+    const oracleValidator = mkPriceOracleValidator(priceOracleParams);
+    const oracleValidatorHash = validatorToScriptHash(oracleValidator);
+    const oracleNft = await runStartPriceOracle(
+      lucid,
+      oracleValidatorHash,
+      priceOracleParams,
+      network,
+      fromText('ORACLE_IBTC'),
+      OCD_ONE,
+    );
+
+    const iassetValHash = validatorToScriptHash(alwaysFailValidator);
+    const dummyAc: AssetClass = { currencySymbol: '', tokenName: '' };
+    const iassetNft = await runCreateIAsset(lucid, network, iassetValHash, {
+      assetName: iassetTokenName,
+      price: { Oracle: oracleNft },
+      interestOracleNft: dummyAc,
+      redemptionRatio: OCD_ONE,
+      maintenanceRatio: OCD_ONE,
+      liquidationRatio: OCD_ONE,
+      debtMintingFeePercentage: OCD_ZERO,
+      liquidationProcessingFeePercentage: OCD_ZERO,
+      stabilityPoolWithdrawalFeePercentage: OCD_ZERO,
+      redemptionReimbursementPercentage: OCD_ONE,
+      redemptionProcessingFeePercentage: OCD_ZERO,
+      interestCollectorPortionPercentage: OCD_ZERO,
+      firstIAsset: true,
+      nextIAsset: null,
+    });
+
+    const lrpParams: LRPParams = {
+      versionRecordToken: {
+        currencySymbol: fromText('smth'),
+        tokenName: fromText('version_record'),
+      },
+      iassetNft: iassetNft,
+      iassetPolicyId: iassetPolicyId,
+      minRedemptionLovelacesAmt: 1_000_000n,
+    };
+
+    const lrpValidator = mkLrpValidator(lrpParams);
+    const lrpValidatorHash = validatorToScriptHash(lrpValidator);
+
+    const lrpRefScriptOutRef = await runCreateScriptRefTx(
+      lucid,
+      lrpValidator,
+      network,
+    );
+
+    await runAndAwaitTx(
+      lucid,
+      openLrp(
+        iassetTokenName,
+        20_000_000n,
+        { getOnChainInt: 1_000_000n },
+        lucid,
+        lrpValidatorHash,
+        network,
+      ),
+    );
+
+    const lrpOutRef = matchSingle(
+      await findLrp(
+        lucid,
+        network,
+        lrpValidatorHash,
+        ownPkh.hash,
+        iassetTokenName,
+      ),
+      (res) => new Error('Expected a single LRP UTXO.: ' + JSON.stringify(res)),
+    );
+
+    await runAndAwaitTx(lucid, cancelLrp(lrpOutRef, lrpRefScriptOutRef, lucid));
+
+    // await runAndAwaitTx(
+    //   lucid,
+    //   redeemLrp(
+    //     [[lrpOutRef, 5_000_000n]],
+    //     lrpRefScriptOutRef,
+    //     await findPriceOracle(lucid, network, oracleValidatorHash, oracleNft),
+    //     await findIAsset(
+    //       lucid,
+    //       network,
+    //       iassetValHash,
+    //       iassetNft,
+    //       iassetTokenName,
+    //     ),
+    //     lucid,
+    //     lrpParams,
+    //     priceOracleParams,
+    //     network,
+    //   ),
+    // );
+  });
+});

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,
+  OutRef,
+  ScriptHash,
+} 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<OutRef[]> {
+  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),
+      ),
+  );
+}