@indigo-labs/indigo-sdk 0.1.28 → 0.2.0

package/tests/queries/iasset-queries.ts

@@ -1,39 +1,62 @@
-import {
-  fromText,
-  LucidEvolution,
-  ScriptHash,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
+import { fromText, LucidEvolution, ScriptHash } from '@lucid-evolution/lucid';
+import { createScriptAddress } from '../../src/utils/lucid-utils';
 import { AssetClass } from '../../src/types/generic';
-import { assetClassToUnit } from '../../src/helpers/value-helpers';
-import { matchSingle, parseIAssetDatum } from '../../src';
+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';
 
 export async function findIAsset(
   lucid: LucidEvolution,
   iassetScriptHash: ScriptHash,
   iassetNft: AssetClass,
+  // Ascii encoded
   iassetName: string,
-): Promise<UTxO> {
+): Promise<IAssetOutput> {
   const iassetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network, iassetScriptHash),
+    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;
-        }
-      }
-    }),
+    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,
+    ),
     (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,13 +1,10 @@
 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';
+import { assetClassToUnit } from '../../src/utils/value-helpers';
 
 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)];
+): Promise<UTxO> {
+  return lucid.utxoByUnit(assetClassToUnit(interestNft));
 }

package/tests/queries/lrp-queries.ts

@@ -5,8 +5,8 @@ import {
   ScriptHash,
   UTxO,
 } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/helpers/lucid-utils';
-import { parseLrpDatum } from '../../src/types/indigo/lrp';
+import { createScriptAddress } from '../../src/utils/lucid-utils';
+import { parseLrpDatum } from '../../src/contracts/lrp/types';
 
 /**
  * Beware, this shouldn't be used in production since it queries all the UTXOs

package/tests/queries/poll-queries.ts

@@ -0,0 +1,97 @@
+import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+import {
+  parsePollManager,
+  parsePollShard,
+  PollManagerContent,
+  PollShardContent,
+} from '../../src/contracts/poll/types-poll';
+import {
+  AssetClass,
+  matchSingle,
+  createScriptAddress,
+  getRandomElement,
+} 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 findPollManager(
+  lucid: LucidEvolution,
+  pollManagerScriptHash: ScriptHash,
+  pollManagerNft: AssetClass,
+  pollId: bigint,
+): Promise<{ utxo: UTxO; datum: PollManagerContent }> {
+  const pollManagerUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, pollManagerScriptHash),
+    assetClassToUnit(pollManagerNft),
+  );
+
+  return matchSingle(
+    F.pipe(
+      pollManagerUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parsePollManager),
+          O.flatMap((datum) => {
+            if (datum.pollId === pollId) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) => new Error('Expected a single Gov UTXO.: ' + JSON.stringify(res)),
+  );
+}
+
+export async function findAllPollShards(
+  lucid: LucidEvolution,
+  pollShardScriptHash: string,
+  pollShardNft: AssetClass,
+  pollId: bigint,
+): Promise<{ utxo: UTxO; datum: PollShardContent }[]> {
+  const pollShardUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(lucid.config().network!, pollShardScriptHash),
+    assetClassToUnit(pollShardNft),
+  );
+
+  return F.pipe(
+    pollShardUtxos.map((utxo) =>
+      F.pipe(
+        O.fromNullable(utxo.datum),
+        O.flatMap(parsePollShard),
+        O.flatMap((datum) => {
+          if (datum.pollId === pollId) {
+            return O.some({ utxo, datum: datum });
+          } else {
+            return O.none;
+          }
+        }),
+      ),
+    ),
+    A.compact,
+  );
+}
+
+export async function findRandomPollShard(
+  lucid: LucidEvolution,
+  pollShardScriptHash: string,
+  pollShardNft: AssetClass,
+  pollId: bigint,
+): Promise<{ utxo: UTxO; datum: PollShardContent }> {
+  const pollShardOuts = await findAllPollShards(
+    lucid,
+    pollShardScriptHash,
+    pollShardNft,
+    pollId,
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(pollShardOuts)),
+    O.match(() => {
+      throw new Error('Expected some poll shard UTXOs.');
+    }, F.identity),
+  );
+}

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

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

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

@@ -2,16 +2,17 @@ import {
   fromText,
   LucidEvolution,
   ScriptHash,
+  toHex,
   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 { assetClassToUnit } from '../../src/utils/value-helpers';
+import { matchSingle } from '../../src';
 import {
-  matchSingle,
   parseAccountDatum,
   parseStabilityPoolDatum,
-} from '../../src';
+} from '../../src/contracts/stability-pool/types-new';
 
 export async function findStabilityPool(
   lucid: LucidEvolution,
@@ -20,7 +21,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),
   );
 
@@ -30,7 +31,7 @@ export async function findStabilityPool(
         try {
           const stabilityPoolDatum = parseStabilityPoolDatum(utxo.datum);
 
-          return stabilityPoolDatum.asset == fromText(asset);
+          return toHex(stabilityPoolDatum.asset) == fromText(asset);
         } catch (_) {
           // when incompatible datum
           return false;
@@ -51,7 +52,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(
@@ -61,7 +62,8 @@ export async function findStabilityPoolAccount(
           const accountDatum = parseAccountDatum(utxo.datum);
 
           return (
-            accountDatum.asset == fromText(asset) && accountDatum.owner == owner
+            toHex(accountDatum.asset) == fromText(asset) &&
+            toHex(accountDatum.owner) == owner
           );
         } catch (_) {
           // when incompatible datum

package/tests/queries/staking-queries.ts

@@ -1,40 +1,49 @@
 import {
   LucidEvolution,
-  Network,
-  OutRef,
   ScriptHash,
+  toHex,
+  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 { assetClassToUnit } from '../../src/utils/value-helpers';
 import { matchSingle } from '../../src';
-import { parseStakingPositionDatum } from '../../src/types/indigo/staking';
+import { option as O, array as A, function as F } from 'fp-ts';
+import {
+  parseStakingPosition,
+  StakingPosition,
+} from '../../src/contracts/staking/types-new';
 
 export async function findStakingPosition(
   lucid: LucidEvolution,
-  network: Network,
   stakingScriptHash: ScriptHash,
   stakingPositionNft: AssetClass,
   owner: string,
-): Promise<OutRef> {
+): Promise<{ utxo: UTxO; datum: StakingPosition }> {
+  const network = lucid.config().network!;
+
   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;
-        }
-      }
-    }),
+    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,
+    ),
     (res) =>
       new Error(
         'Expected a single Staking Position UTXO.: ' + JSON.stringify(res),

package/tests/queries/treasury-queries.ts

@@ -0,0 +1,19 @@
+import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
+import { createScriptAddress, getRandomElement } from '../../src';
+import { option as O, function as F } from 'fp-ts';
+
+export async function findRandomTreasuryUtxo(
+  lucid: LucidEvolution,
+  treasuryScriptHash: ScriptHash,
+): Promise<UTxO> {
+  const treasuryUtxos = await lucid.utxosAt(
+    createScriptAddress(lucid.config().network!, treasuryScriptHash),
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(treasuryUtxos)),
+    O.match(() => {
+      throw new Error('Expected some treasury UTXOs.');
+    }, F.identity),
+  );
+}