@indigo-labs/indigo-sdk 0.1.19 → 0.1.21

package/tests/lrp.test.ts

@@ -11,23 +11,23 @@ import {
   UTxO,
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
-import { LRPParams, parseLrpDatum } 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 { LRPParams, parseLrpDatum } from '../src/contracts/lrp/types';
+import { mkLrpValidator } from '../src/contracts/lrp/scripts';
+import { runCreateScriptRefTx } from '../src/utils/helper-txs';
+import { runOneShotMintTx } from '../src/contracts/one-shot/transactions';
 import {
   adjustLrp,
   cancelLrp,
   claimLrp,
   openLrp,
   redeemLrp,
-} from '../src/contracts/lrp';
+} from '../src/contracts/lrp/transactions';
 import { findLrp } from './queries/lrp-queries';
-import { addrDetails, getInlineDatumOrThrow } 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 { addrDetails, getInlineDatumOrThrow } from '../src/utils/lucid-utils';
+import { runAndAwaitTx, runAndAwaitTxBuilder } from './test-helpers';
+import { matchSingle } from '../src/utils/utils';
+import { runCreateIAsset } from './indigo-test-helpers';
+import { mkPriceOracleValidator } from '../src/contracts/price-oracle/scripts';
 import { AssetClass, OracleAssetNft, PriceOracleParams } from '../src';
 import { alwaysFailValidator } from '../src/scripts/always-fail-validator';
 import {
@@ -37,8 +37,9 @@ import {
 } from '../src/types/on-chain-decimal';
 import { findPriceOracle } from './queries/price-oracle-queries';
 import { findIAsset } from './queries/iasset-queries';
-import { assetClassValueOf, lovelacesAmt } from '../src/helpers/value-helpers';
+import { assetClassValueOf, lovelacesAmt } from '../src/utils/value-helpers';
 import { strictEqual } from 'assert';
+import { startPriceOracleTx } from '../src/contracts/price-oracle/transactions';
 
 type LRPTestContext = {
   iassetAc: AssetClass;
@@ -77,19 +78,19 @@ async function initTest(
   };
   const oracleValidator = mkPriceOracleValidator(priceOracleParams);
   const oracleValidatorHash = validatorToScriptHash(oracleValidator);
-  const oracleNft = await runStartPriceOracle(
+  const [tx, oracleNft] = await startPriceOracleTx(
     lucid,
-    oracleValidatorHash,
-    priceOracleParams,
-    network,
-    fromText('ORACLE_IBTC'),
+    'ORACLE_IBTC',
     iassetPrice,
+    priceOracleParams,
   );
 
+  await runAndAwaitTxBuilder(lucid, tx);
+
   const iassetValHash = validatorToScriptHash(alwaysFailValidator);
   const iassetNft = await runCreateIAsset(lucid, network, iassetValHash, {
     assetName: iassetTokenName,
-    price: { Oracle: oracleNft },
+    price: { Oracle: { content: oracleNft } },
     interestOracleNft: { currencySymbol: '', tokenName: '' },
     redemptionRatio: OCD_ONE,
     maintenanceRatio: OCD_ONE,
@@ -199,7 +200,7 @@ describe('LRP', () => {
       lovelacesAmt(adjustedUtxo1.assets) >=
         parseLrpDatum(getInlineDatumOrThrow(adjustedUtxo1)).lovelacesToSpend,
       'Lovelaces to spend has to be smaller than actual lovelaces in UTXO',
-    );
+    ).toBeTruthy();
 
     await runAndAwaitTx(
       lucid,
@@ -234,7 +235,7 @@ describe('LRP', () => {
       lovelacesAmt(adjustedUtxo2.assets) >=
         parseLrpDatum(getInlineDatumOrThrow(adjustedUtxo2)).lovelacesToSpend,
       'Lovelaces to spend has to be smaller than actual lovelaces in UTXO',
-    );
+    ).toBeTruthy();
   });
 
   it('claim', async () => {
@@ -323,18 +324,15 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(
-          lucid,
-          network,
-          testCtx.oracleValHash,
-          testCtx.oracleNft,
-        ),
-        await findIAsset(
-          lucid,
-          testCtx.iassetValHash,
-          testCtx.iassetNft,
-          toText(iassetTokenName),
-        ),
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
         lucid,
         lrpParams,
         network,
@@ -449,18 +447,15 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(
-          lucid,
-          network,
-          testCtx.oracleValHash,
-          testCtx.oracleNft,
-        ),
-        await findIAsset(
-          lucid,
-          testCtx.iassetValHash,
-          testCtx.iassetNft,
-          toText(iassetTokenName),
-        ),
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
         lucid,
         lrpParams,
         network,
@@ -495,7 +490,7 @@ describe('LRP', () => {
     );
   });
 
-  it('redeem, redeem again and cancel', async () => {
+  it('single redemption and cancel', async () => {
     const network: Network = 'Custom';
     const account1 = generateEmulatorAccount({
       lovelace: 80_000_000_000n, // 80,000 ADA
@@ -581,18 +576,130 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
+        lucid,
+        lrpParams,
+        network,
+      ),
+    );
+
+    const redeemedLrp = await findSingleOwnLrp();
+
+    strictEqual(
+      assetClassValueOf(redeemedLrp.assets, redemptionAsset),
+      redemptionIAssetAmt,
+      'LRP has wrong number of iassets after redemption',
+    );
+
+    await runAndAwaitTx(
+      lucid,
+      cancelLrp(redeemedLrp, lrpRefScriptOutRef, lucid),
+    );
+  });
+
+  it('redeem, redeem again and cancel', 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('iBTC');
+    const testCtx = await initTest(
+      lucid,
+      network,
+      iassetTokenName,
+      10_000_000n,
+      OCD_ONE,
+    );
+
+    const [ownPkh, _] = await addrDetails(lucid);
+
+    const lrpParams: LRPParams = {
+      versionRecordToken: {
+        currencySymbol: fromText('smth'),
+        tokenName: fromText('version_record'),
+      },
+      iassetNft: testCtx.iassetNft,
+      iassetPolicyId: testCtx.iassetAc.currencySymbol,
+      minRedemptionLovelacesAmt: 1_000_000n,
+    };
+
+    const lrpValidator = mkLrpValidator(lrpParams);
+    const lrpValidatorHash = validatorToScriptHash(lrpValidator);
+    const lrpRefScriptOutRef = await runCreateScriptRefTx(
+      lucid,
+      lrpValidator,
+      network,
+    );
+
+    const findSingleOwnLrp = async (): Promise<UTxO> => {
+      return matchSingle(
+        await findLrp(
           lucid,
           network,
-          testCtx.oracleValHash,
-          testCtx.oracleNft,
-        ),
-        await findIAsset(
-          lucid,
-          testCtx.iassetValHash,
-          testCtx.iassetNft,
-          toText(iassetTokenName),
+          lrpValidatorHash,
+          ownPkh.hash,
+          iassetTokenName,
         ),
+        (res) =>
+          new Error('Expected a single LRP UTXO.: ' + JSON.stringify(res)),
+      );
+    };
+
+    await runAndAwaitTx(
+      lucid,
+      openLrp(
+        iassetTokenName,
+        20_000_000n,
+        { getOnChainInt: 1_000_000n },
+        lucid,
+        lrpValidatorHash,
+        network,
+      ),
+    );
+
+    const lrpUtxo = await findSingleOwnLrp();
+
+    const redemptionAsset: AssetClass = {
+      currencySymbol: testCtx.iassetAc.currencySymbol,
+      tokenName: iassetTokenName,
+    };
+
+    strictEqual(
+      assetClassValueOf(lrpUtxo.assets, redemptionAsset),
+      0n,
+      'LRP should have no iassets before redemption',
+    );
+
+    const redemptionIAssetAmt = 5_000_000n;
+
+    await runAndAwaitTx(
+      lucid,
+      redeemLrp(
+        [[lrpUtxo, redemptionIAssetAmt]],
+        lrpRefScriptOutRef,
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
         lucid,
         lrpParams,
         network,
@@ -606,29 +713,27 @@ describe('LRP', () => {
       redeemLrp(
         [[redeemedLrp, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(
-          lucid,
-          network,
-          testCtx.oracleValHash,
-          testCtx.oracleNft,
-        ),
-        await findIAsset(
-          lucid,
-          testCtx.iassetValHash,
-          testCtx.iassetNft,
-          toText(iassetTokenName),
-        ),
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
         lucid,
         lrpParams,
         network,
       ),
     );
-    
+
     strictEqual(
       assetClassValueOf(redeemedLrp.assets, redemptionAsset),
       redemptionIAssetAmt,
       'LRP has wrong number of iassets after redemption',
     );
+
     const closableLrp = await findSingleOwnLrp();
 
     await runAndAwaitTx(
@@ -736,18 +841,15 @@ describe('LRP', () => {
           [lrpUtxo2, 4_000_000n],
         ],
         lrpRefScriptOutRef,
-        await findPriceOracle(
-          lucid,
-          network,
-          testCtx.oracleValHash,
-          testCtx.oracleNft,
-        ),
-        await findIAsset(
-          lucid,
-          testCtx.iassetValHash,
-          testCtx.iassetNft,
-          toText(iassetTokenName),
-        ),
+        await findPriceOracle(lucid, testCtx.oracleNft),
+        (
+          await findIAsset(
+            lucid,
+            testCtx.iassetValHash,
+            testCtx.iassetNft,
+            toText(iassetTokenName),
+          )
+        ).utxo,
         lucid,
         lrpParams,
         network,

package/tests/mock/assets-mock.ts

@@ -0,0 +1,59 @@
+export type InitialAsset = {
+  name: string;
+  priceOracle: {
+    tokenName: string;
+    startPrice: bigint;
+    params: {
+      biasTime: bigint;
+      expirationTime: bigint;
+    };
+  };
+  initerestOracle: {
+    tokenName: string;
+    initialInterestRate: bigint;
+    params: {
+      biasTime: bigint;
+    };
+  };
+  redemptionRatioPercentage: bigint;
+  maintenanceRatioPercentage: bigint;
+  liquidationRatioPercentage: bigint;
+  debtMintingFeePercentage: bigint;
+  liquidationProcessingFeePercentage: bigint;
+  stabilityPoolWithdrawalFeePercentage: bigint;
+  redemptionReimbursementPercentage: bigint;
+  redemptionProcessingFeePercentage: bigint;
+  interestCollectorPortionPercentage: bigint;
+  firstAsset: boolean;
+  nextAsset?: string;
+};
+
+export const iusdInitialAssetCfg: InitialAsset = {
+  name: 'iUSD',
+  priceOracle: {
+    tokenName: 'iUSD_ORACLE',
+    startPrice: 1_000_000n,
+    params: {
+      biasTime: 120_000n,
+      expirationTime: 1_800_000n,
+    },
+  },
+  initerestOracle: {
+    tokenName: 'iUSD_ORACLE',
+    initialInterestRate: 1_000_000n,
+    params: {
+      biasTime: 120_000n,
+    },
+  },
+  redemptionRatioPercentage: 200_000_000n,
+  maintenanceRatioPercentage: 150_000_000n,
+  liquidationRatioPercentage: 120_000_000n,
+  debtMintingFeePercentage: 500_000n,
+  liquidationProcessingFeePercentage: 2_000_000n,
+  stabilityPoolWithdrawalFeePercentage: 500_000n,
+  redemptionReimbursementPercentage: 1_000_000n,
+  redemptionProcessingFeePercentage: 1_000_000n,
+  interestCollectorPortionPercentage: 40_000_000n,
+  firstAsset: true,
+  nextAsset: undefined,
+};

package/tests/queries/cdp-queries.ts

@@ -0,0 +1,144 @@
+import {
+  Credential,
+  fromText,
+  LucidEvolution,
+  ScriptHash,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  AssetClass,
+  CDPContent,
+  createScriptAddress,
+  fromSystemParamsAsset,
+  getRandomElement,
+  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';
+
+export async function findAllActiveCdps(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  assetAscii: string,
+  stakeCred?: Credential,
+): Promise<{ utxo: UTxO; datum: CDPContent }[]> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.cdpHash,
+      stakeCred,
+    ),
+    assetClassToUnit(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken)),
+  );
+
+  return F.pipe(
+    cdpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseCdpDatum),
+        O.flatMap((datum) => {
+          if (datum.iasset === fromText(assetAscii) && datum.cdpOwner) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}
+
+export async function findCdp(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+  ownerPkh: string,
+  stakeCred?: Credential,
+): Promise<{ utxo: UTxO; datum: CDPContent }> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpScriptHash, stakeCred),
+    assetClassToUnit(cdpNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      cdpUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseCdpDatum),
+          O.flatMap((datum) => {
+            if (datum.cdpOwner === ownerPkh) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) => new Error('Expected a single CDP UTXO.: ' + JSON.stringify(res)),
+  );
+}
+
+export async function findFrozenCDPs(
+  lucid: LucidEvolution,
+  cdpScriptHash: ScriptHash,
+  cdpNft: AssetClass,
+  assetAscii: string,
+): Promise<{ utxo: UTxO; datum: CDPContent }[]> {
+  const cdpUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpScriptHash),
+    assetClassToUnit(cdpNft),
+  );
+
+  return F.pipe(
+    cdpUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parseCdpDatum),
+        O.flatMap((datum) => {
+          if (datum.cdpOwner == null && datum.iasset === fromText(assetAscii)) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}
+
+export async function findAllCdpCreators(
+  lucid: LucidEvolution,
+  cdpCreatorScriptHash: string,
+  cdpCreatorNft: AssetClass,
+): Promise<UTxO[]> {
+  return lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, cdpCreatorScriptHash),
+    assetClassToUnit(cdpCreatorNft),
+  );
+}
+
+export async function findRandomCdpCreator(
+  lucid: LucidEvolution,
+  cdpCreatorScriptHash: string,
+  cdpCreatorNft: AssetClass,
+): Promise<UTxO> {
+  const cdpCreatorUtxos = await findAllCdpCreators(
+    lucid,
+    cdpCreatorScriptHash,
+    cdpCreatorNft,
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
+    O.match(() => {
+      throw new Error('Expected some cdp creator UTXOs.');
+    }, F.identity),
+  );
+}

package/tests/queries/collector-queries.ts

@@ -0,0 +1,26 @@
+import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
+import { createScriptAddress, getRandomElement } from '../../src';
+import { option as O, function as F } from 'fp-ts';
+
+export async function findAllCollectors(
+  lucid: LucidEvolution,
+  collectorScriptHash: string,
+): Promise<UTxO[]> {
+  return lucid.utxosAt(
+    createScriptAddress(lucid.config().network!, collectorScriptHash),
+  );
+}
+
+export async function findRandomCollector(
+  lucid: LucidEvolution,
+  collectorScriptHash: string,
+): Promise<UTxO> {
+  const allCollectors = await findAllCollectors(lucid, collectorScriptHash);
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(allCollectors)),
+    O.match(() => {
+      throw new Error('Expected some poll shard UTXOs.');
+    }, F.identity),
+  );
+}

package/tests/queries/execute-queries.ts

@@ -0,0 +1,46 @@
+import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+import {
+  AssetClass,
+  createScriptAddress,
+  ExecuteDatum,
+  matchSingle,
+  parseExecuteDatum,
+} from '../../src';
+import { assetClassToUnit } from '../../src/utils/value-helpers';
+import { option as O, array as A, function as F } from 'fp-ts';
+
+export async function findExecute(
+  lucid: LucidEvolution,
+  executeHash: ScriptHash,
+  executeNft: AssetClass,
+  upgradeId: bigint,
+): Promise<{
+  utxo: UTxO;
+  datum: ExecuteDatum;
+}> {
+  const executeUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, executeHash),
+    assetClassToUnit(executeNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      executeUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseExecuteDatum),
+          O.flatMap((datum) => {
+            if (datum.id === upgradeId) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error('Expected a single Execute UTXO.: ' + JSON.stringify(res)),
+  );
+}

package/tests/queries/governance-queries.ts

@@ -1,31 +1,34 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { createScriptAddress } from '../../src/utils/lucid-utils';
 import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/helpers/value-helpers';
-import { matchSingle, parseGovDatum } from '../../src';
+import { assetClassToUnit } from '../../src/utils/value-helpers';
+import { GovDatum, matchSingle, parseGovDatum } from '../../src';
+import { option as O, array as A, function as F } from 'fp-ts';
 
 export async function findGov(
   lucid: LucidEvolution,
   govScriptHash: ScriptHash,
   govNft: AssetClass,
-): Promise<UTxO> {
+): Promise<{
+  utxo: UTxO;
+  datum: GovDatum;
+}> {
   const govUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network, govScriptHash),
+    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;
-        }
-      }
-    }),
+    F.pipe(
+      govUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseGovDatum),
+          O.map((datum) => ({ utxo, datum: datum })),
+        ),
+      ),
+      A.compact,
+    ),
     (res) => new Error('Expected a single Gov UTXO.: ' + JSON.stringify(res)),
   );
 }