@indigo-labs/indigo-sdk 0.1.21 → 0.1.22

package/tests/lrp.test.ts

@@ -11,23 +11,23 @@ import {
   UTxO,
   validatorToScriptHash,
 } from '@lucid-evolution/lucid';
-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 { 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 {
   adjustLrp,
   cancelLrp,
   claimLrp,
   openLrp,
   redeemLrp,
-} from '../src/contracts/lrp/transactions';
+} from '../src/contracts/lrp';
 import { findLrp } from './queries/lrp-queries';
-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 { 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 { AssetClass, OracleAssetNft, PriceOracleParams } from '../src';
 import { alwaysFailValidator } from '../src/scripts/always-fail-validator';
 import {
@@ -37,9 +37,8 @@ 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/utils/value-helpers';
+import { assetClassValueOf, lovelacesAmt } from '../src/helpers/value-helpers';
 import { strictEqual } from 'assert';
-import { startPriceOracleTx } from '../src/contracts/price-oracle/transactions';
 
 type LRPTestContext = {
   iassetAc: AssetClass;
@@ -78,19 +77,19 @@ async function initTest(
   };
   const oracleValidator = mkPriceOracleValidator(priceOracleParams);
   const oracleValidatorHash = validatorToScriptHash(oracleValidator);
-  const [tx, oracleNft] = await startPriceOracleTx(
+  const oracleNft = await runStartPriceOracle(
     lucid,
-    'ORACLE_IBTC',
-    iassetPrice,
+    oracleValidatorHash,
     priceOracleParams,
+    network,
+    fromText('ORACLE_IBTC'),
+    iassetPrice,
   );
 
-  await runAndAwaitTxBuilder(lucid, tx);
-
   const iassetValHash = validatorToScriptHash(alwaysFailValidator);
   const iassetNft = await runCreateIAsset(lucid, network, iassetValHash, {
     assetName: iassetTokenName,
-    price: { Oracle: { content: oracleNft } },
+    price: { Oracle: oracleNft },
     interestOracleNft: { currencySymbol: '', tokenName: '' },
     redemptionRatio: OCD_ONE,
     maintenanceRatio: OCD_ONE,
@@ -200,7 +199,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,
@@ -235,7 +234,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 () => {
@@ -324,15 +323,18 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(lucid, testCtx.oracleNft),
-        (
-          await findIAsset(
-            lucid,
-            testCtx.iassetValHash,
-            testCtx.iassetNft,
-            toText(iassetTokenName),
-          )
-        ).utxo,
+        await findPriceOracle(
+          lucid,
+          network,
+          testCtx.oracleValHash,
+          testCtx.oracleNft,
+        ),
+        await findIAsset(
+          lucid,
+          testCtx.iassetValHash,
+          testCtx.iassetNft,
+          toText(iassetTokenName),
+        ),
         lucid,
         lrpParams,
         network,
@@ -447,15 +449,18 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        await findPriceOracle(lucid, testCtx.oracleNft),
-        (
-          await findIAsset(
-            lucid,
-            testCtx.iassetValHash,
-            testCtx.iassetNft,
-            toText(iassetTokenName),
-          )
-        ).utxo,
+        await findPriceOracle(
+          lucid,
+          network,
+          testCtx.oracleValHash,
+          testCtx.oracleNft,
+        ),
+        await findIAsset(
+          lucid,
+          testCtx.iassetValHash,
+          testCtx.iassetNft,
+          toText(iassetTokenName),
+        ),
         lucid,
         lrpParams,
         network,
@@ -576,130 +581,18 @@ describe('LRP', () => {
       redeemLrp(
         [[lrpUtxo, redemptionIAssetAmt]],
         lrpRefScriptOutRef,
-        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(
+        await findPriceOracle(
           lucid,
           network,
-          lrpValidatorHash,
-          ownPkh.hash,
-          iassetTokenName,
+          testCtx.oracleValHash,
+          testCtx.oracleNft,
+        ),
+        await findIAsset(
+          lucid,
+          testCtx.iassetValHash,
+          testCtx.iassetNft,
+          toText(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,
@@ -708,37 +601,15 @@ describe('LRP', () => {
 
     const redeemedLrp = await findSingleOwnLrp();
 
-    await runAndAwaitTx(
-      lucid,
-      redeemLrp(
-        [[redeemedLrp, redemptionIAssetAmt]],
-        lrpRefScriptOutRef,
-        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(
       lucid,
-      cancelLrp(closableLrp, lrpRefScriptOutRef, lucid),
+      cancelLrp(redeemedLrp, lrpRefScriptOutRef, lucid),
     );
   });
 
@@ -841,15 +712,18 @@ describe('LRP', () => {
           [lrpUtxo2, 4_000_000n],
         ],
         lrpRefScriptOutRef,
-        await findPriceOracle(lucid, testCtx.oracleNft),
-        (
-          await findIAsset(
-            lucid,
-            testCtx.iassetValHash,
-            testCtx.iassetNft,
-            toText(iassetTokenName),
-          )
-        ).utxo,
+        await findPriceOracle(
+          lucid,
+          network,
+          testCtx.oracleValHash,
+          testCtx.oracleNft,
+        ),
+        await findIAsset(
+          lucid,
+          testCtx.iassetValHash,
+          testCtx.iassetNft,
+          toText(iassetTokenName),
+        ),
         lucid,
         lrpParams,
         network,

package/tests/queries/governance-queries.ts

@@ -1,34 +1,31 @@
 import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
 import { AssetClass } from '../../src/types/generic';
-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';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { matchSingle, parseGovDatum } from '../../src';
 
 export async function findGov(
   lucid: LucidEvolution,
   govScriptHash: ScriptHash,
   govNft: AssetClass,
-): Promise<{
-  utxo: UTxO;
-  datum: GovDatum;
-}> {
+): Promise<UTxO> {
   const govUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, govScriptHash),
+    createScriptAddress(lucid.config().network, govScriptHash),
     assetClassToUnit(govNft),
   );
 
   return matchSingle(
-    F.pipe(
-      govUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseGovDatum),
-          O.map((datum) => ({ utxo, datum: datum })),
-        ),
-      ),
-      A.compact,
-    ),
+    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

@@ -1,62 +1,39 @@
-import { fromText, LucidEvolution, ScriptHash } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
+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/utils/value-helpers';
-import { IAssetOutput, matchSingle, parseIAssetDatum } from '../../src';
-import { option as O, array as A, function as F } from 'fp-ts';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { matchSingle, parseIAssetDatum } from '../../src';
 
 export async function findIAsset(
   lucid: LucidEvolution,
   iassetScriptHash: ScriptHash,
   iassetNft: AssetClass,
-  // Ascii encoded
   iassetName: string,
-): Promise<IAssetOutput> {
+): Promise<UTxO> {
   const iassetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, iassetScriptHash),
+    createScriptAddress(lucid.config().network, iassetScriptHash),
     assetClassToUnit(iassetNft),
   );
 
   return matchSingle(
-    F.pipe(
-      iassetUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseIAssetDatum),
-          O.flatMap((datum) => {
-            if (datum.assetName === fromText(iassetName)) {
-              return O.some({ utxo, datum: datum });
-            } else {
-              return O.none;
-            }
-          }),
-        ),
-      ),
-      A.compact,
-    ),
+    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)),
   );
 }
-
-export async function findAllIAssets(
-  lucid: LucidEvolution,
-  iassetScriptHash: ScriptHash,
-  iassetNft: AssetClass,
-): Promise<IAssetOutput[]> {
-  const iassetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, iassetScriptHash),
-    assetClassToUnit(iassetNft),
-  );
-
-  return F.pipe(
-    iassetUtxos.map((utxo) =>
-      F.pipe(
-        O.fromNullable(utxo.datum),
-        O.flatMap(parseIAssetDatum),
-        O.map((datum) => ({ utxo, datum: datum })),
-      ),
-    ),
-    A.compact,
-  );
-}

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

@@ -1,10 +1,13 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
 import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
+import { InterestOracleDatum, parseInterestOracleDatum } from '../../src';
 
 export async function findInterestOracle(
   lucid: LucidEvolution,
   interestNft: AssetClass,
-): Promise<UTxO> {
-  return lucid.utxoByUnit(assetClassToUnit(interestNft));
+): 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

@@ -5,8 +5,8 @@ import {
   ScriptHash,
   UTxO,
 } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { parseLrpDatum } from '../../src/contracts/lrp/types';
+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

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

@@ -1,10 +1,27 @@
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { OracleAssetNft } from '../../src';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
+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<UTxO> {
-  return lucid.utxoByUnit(assetClassToUnit(oracleNft.oracleNft));
+): 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

@@ -2,17 +2,16 @@ import {
   fromText,
   LucidEvolution,
   ScriptHash,
-  toHex,
   UTxO,
 } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
 import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
-import { matchSingle } from '../../src';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
 import {
+  matchSingle,
   parseAccountDatum,
   parseStabilityPoolDatum,
-} from '../../src/contracts/stability-pool/types-new';
+} from '../../src';
 
 export async function findStabilityPool(
   lucid: LucidEvolution,
@@ -21,7 +20,7 @@ export async function findStabilityPool(
   asset: string,
 ): Promise<UTxO> {
   const stakingUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, stabilityPoolHash),
+    createScriptAddress(lucid.config().network, stabilityPoolHash),
     assetClassToUnit(stabilityPoolToken),
   );
 
@@ -31,7 +30,7 @@ export async function findStabilityPool(
         try {
           const stabilityPoolDatum = parseStabilityPoolDatum(utxo.datum);
 
-          return toHex(stabilityPoolDatum.asset) == fromText(asset);
+          return stabilityPoolDatum.asset == fromText(asset);
         } catch (_) {
           // when incompatible datum
           return false;
@@ -52,7 +51,7 @@ export async function findStabilityPoolAccount(
   asset: string,
 ): Promise<UTxO> {
   const accountUtxos = await lucid.utxosAt(
-    createScriptAddress(lucid.config().network!, stabilityPoolHash),
+    createScriptAddress(lucid.config().network, stabilityPoolHash),
   );
 
   return matchSingle(
@@ -62,8 +61,7 @@ export async function findStabilityPoolAccount(
           const accountDatum = parseAccountDatum(utxo.datum);
 
           return (
-            toHex(accountDatum.asset) == fromText(asset) &&
-            toHex(accountDatum.owner) == owner
+            accountDatum.asset == fromText(asset) && accountDatum.owner == owner
           );
         } catch (_) {
           // when incompatible datum

package/tests/queries/staking-queries.ts

@@ -1,49 +1,40 @@
 import {
   LucidEvolution,
+  Network,
+  OutRef,
   ScriptHash,
-  toHex,
-  UTxO,
 } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
+import { createScriptAddress } from '../../src/helpers/lucid-utils';
 import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/utils/value-helpers';
+import { assetClassToUnit } from '../../src/helpers/value-helpers';
 import { matchSingle } from '../../src';
-import { option as O, array as A, function as F } from 'fp-ts';
-import {
-  parseStakingPosition,
-  StakingPosition,
-} from '../../src/contracts/staking/types-new';
+import { parseStakingPositionDatum } from '../../src/types/indigo/staking';
 
 export async function findStakingPosition(
   lucid: LucidEvolution,
+  network: Network,
   stakingScriptHash: ScriptHash,
   stakingPositionNft: AssetClass,
   owner: string,
-): Promise<{ utxo: UTxO; datum: StakingPosition }> {
-  const network = lucid.config().network!;
-
+): Promise<OutRef> {
   const stakingUtxos = await lucid.utxosAtWithUnit(
     createScriptAddress(network, stakingScriptHash),
     assetClassToUnit(stakingPositionNft),
   );
 
   return matchSingle(
-    F.pipe(
-      stakingUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseStakingPosition),
-          O.flatMap((datum) => {
-            if (toHex(datum.owner) === owner) {
-              return O.some({ utxo, datum: datum });
-            } else {
-              return O.none;
-            }
-          }),
-        ),
-      ),
-      A.compact,
-    ),
+    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),