@indigo-labs/indigo-sdk 0.3.28 → 0.4.1

package/package.json

@@ -1,22 +1,10 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.3.28",
+  "version": "0.4.1",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.build.json",
-    "type-check": "tsc --noEmit",
-    "lint": "pnpm eslint .",
-    "lint:fix": "npx eslint --fix .",
-    "repack": "pnpm run build  && pnpm pack",
-    "format": "npx prettier --write src/ tests/",
-    "format:check": "npx prettier --check src/ tests/",
-    "test": "vitest run",
-    "prepare": "husky",
-    "lint-staged": "lint-staged"
-  },
   "lint-staged": {
     "*.{js,ts,jsx,tsx}": [
       "prettier --write",
@@ -39,12 +27,11 @@
   ],
   "author": "3rd Eye Labs",
   "license": "MIT",
-  "packageManager": "pnpm@10.33.4",
   "dependencies": {
-    "@3rd-eye-labs/cardano-offchain-common": "1.2.0",
+    "@3rd-eye-labs/cardano-offchain-common": "1.4.7",
     "@evolution-sdk/evolution": "^0.3.22",
     "@harmoniclabs/crypto": "^0.3.0",
-    "@lucid-evolution/lucid": "^0.4.29",
+    "@lucid-evolution/lucid": "0.5.5",
     "@noble/ed25519": "^3.0.0",
     "@pythnetwork/pyth-lazer-sdk": "^6.0.0",
     "decimal.js": "^10.6.0",
@@ -71,10 +58,15 @@
     "typescript-eslint": "^8.39.0",
     "vitest": "^4.0.14"
   },
-  "pnpm": {
-    "overrides": {
-      "libsodium-wrappers-sumo": "0.8.2",
-      "libsodium-sumo": "0.8.2"
-    }
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --tsconfig tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "lint": "pnpm eslint .",
+    "lint:fix": "npx eslint --fix .",
+    "repack": "pnpm run build  && pnpm pack",
+    "format": "npx prettier --write src/ tests/",
+    "format:check": "npx prettier --check src/ tests/",
+    "test": "vitest run",
+    "lint-staged": "lint-staged"
   }
-}
+}

package/src/contracts/cdp-creator/queries.ts

@@ -0,0 +1,30 @@
+import {
+  assetClassToUnit,
+  getRandomElement,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
+import { option as O, function as F } from 'fp-ts';
+import { createScriptAddress } from '../../utils/lucid-utils';
+import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
+
+export async function findRandomCdpCreator(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<UTxO> {
+  const cdpCreatorUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.cdpCreatorHash,
+    ),
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
+    ),
+  );
+
+  return F.pipe(
+    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
+    O.match(() => {
+      throw new Error('Expected some cdp creator UTXOs.');
+    }, F.identity),
+  );
+}

package/src/contracts/iasset/queries.ts

@@ -0,0 +1,102 @@
+import { LucidEvolution, toHex } from '@lucid-evolution/lucid';
+import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
+import {
+  AssetClass,
+  assetClassToUnit,
+  isSameAssetClass,
+  matchSingle,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  CollateralAssetOutput,
+  IAssetOutput,
+  parseCollateralAssetDatum,
+  parseIAssetDatum,
+} from './types';
+import { createScriptAddress } from '../../utils/lucid-utils';
+import { option as O, array as A, function as F } from 'fp-ts';
+
+export async function findIAsset(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  /**
+   * For conversion from hex use the `fromHex` function from lucid-evolution.
+   */
+  iassetName: Uint8Array<ArrayBufferLike>,
+): Promise<IAssetOutput> {
+  const iassetUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.iassetHash,
+    ),
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    ),
+  );
+
+  return matchSingle(
+    F.pipe(
+      iassetUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseIAssetDatum),
+          O.flatMap((datum) => {
+            if (toHex(datum.assetName) === toHex(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 findCollateralAsset(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+  /**
+   * For conversion from hex use the `fromHex` function from lucid-evolution.
+   */
+  iassetName: Uint8Array<ArrayBufferLike>,
+  collateralAsset: AssetClass,
+): Promise<CollateralAssetOutput> {
+  const collateralAssetUtxos = await lucid.utxosAtWithUnit(
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.iassetHash,
+    ),
+    assetClassToUnit(
+      fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
+    ),
+  );
+
+  return matchSingle(
+    F.pipe(
+      collateralAssetUtxos.map((utxo) =>
+        F.pipe(
+          O.fromNullable(utxo.datum),
+          O.flatMap(parseCollateralAssetDatum),
+          O.flatMap((datum) => {
+            if (
+              isSameAssetClass(datum.collateralAsset, collateralAsset) &&
+              toHex(iassetName) === toHex(datum.iasset)
+            ) {
+              return O.some({ utxo, datum: datum });
+            } else {
+              return O.none;
+            }
+          }),
+        ),
+      ),
+      A.compact,
+    ),
+    (res) =>
+      new Error(
+        'Expected a single Collateral Asset UTXO.: ' + JSON.stringify(res),
+      ),
+  );
+}

package/src/contracts/initialize/actions.ts

@@ -69,7 +69,6 @@ import { mkStabilityPoolValidatorFromSP } from '../stability-pool/scripts';
 import { mkTreasuryValidatorFromSP } from '../treasury/scripts';
 import { mkCDPCreatorValidatorFromSP } from '../cdp-creator/scripts';
 import { mkGovValidatorFromSP } from '../gov/scripts';
-import { submitTx } from '../../utils/lucid-utils';
 import {
   deriveAuthToken,
   initScriptRef,
@@ -121,17 +120,29 @@ export async function initPythConfig(
             pythFeedValidator,
           );
 
-          // Register the stake key for pyth feed validator.
-          await runAndAwaitTxBuilder(
-            lucid,
-            lucid.newTx().register.Stake(
-              credentialToRewardAddress(lucid.config().network!, {
-                hash: validatorToScriptHash(pythFeedValidator),
-                type: 'Script',
-              }),
-            ),
-          );
-
+          try {
+            // Register the stake key for pyth feed validator.
+            await runAndAwaitTxBuilder(
+              lucid,
+              lucid.newTx().register.Stake(
+                credentialToRewardAddress(lucid.config().network!, {
+                  hash: validatorToScriptHash(pythFeedValidator),
+                  type: 'Script',
+                }),
+              ),
+            );
+          } catch (error) {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            if (
+              !message.includes('StakeKeyRegisteredDELEG') &&
+              !message.includes(
+                'Trying to re-register some already known credentials.',
+              )
+            ) {
+              throw error;
+            }
+          }
           const key = `${asset.name}/${toHex(collateral.collateralAsset.currencySymbol)}.${toHex(collateral.collateralAsset.tokenName)}`;
 
           return {
@@ -368,8 +379,20 @@ export async function init(
     scriptHashToCredential(cdpRedeemValHash),
   );
 
-  await submitTx(lucid, lucid.newTx().register.Stake(cdpRedeemRewardAddr));
-
+  try {
+    await runAndAwaitTxBuilder(
+      lucid,
+      lucid.newTx().register.Stake(cdpRedeemRewardAddr),
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (
+      !message.includes('StakeKeyRegisteredDELEG') &&
+      !message.includes('Trying to re-register some already known credentials.')
+    ) {
+      throw error;
+    }
+  }
   const cdpParams: CdpParamsSP = {
     cdpAuthToken: toSystemParamsAsset(cdpToken),
     cdpAssetSymbol: { unCurrencySymbol: assetSymbol },
@@ -578,7 +601,7 @@ export async function init(
     lucid,
     govParams,
     govNftAsset,
-    defaultInitialAssets,
+    initialAssets,
     protocolParams,
   );
 

package/{tests/interest-collection/interest-collector-queries.ts → src/contracts/interest-collection/queries.ts}

@@ -1,32 +1,41 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src';
 import { option as O, function as F } from 'fp-ts';
 import {
-  AssetClass,
   assetClassToUnit,
   assetClassValueOf,
   getRandomElement,
   matchSingle,
 } from '@3rd-eye-labs/cardano-offchain-common';
+import { createScriptAddress } from '../../utils/lucid-utils';
+import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
 
 export async function findAllInterestCollectors(
   lucid: LucidEvolution,
-  interestCollectorScriptHash: string,
+  sysParams: SystemParams,
 ): Promise<UTxO[]> {
   return lucid.utxosAt(
-    createScriptAddress(lucid.config().network!, interestCollectorScriptHash),
+    createScriptAddress(
+      lucid.config().network!,
+      sysParams.validatorHashes.interestCollectionHash,
+    ),
   );
 }
 
 export async function findAdminInterestCollectors(
   lucid: LucidEvolution,
-  interestCollectorScriptHash: string,
-  multisigUtxoNft: AssetClass,
+  sysParams: SystemParams,
 ): Promise<UTxO> {
   return matchSingle(
     await lucid.utxosAtWithUnit(
-      createScriptAddress(lucid.config().network!, interestCollectorScriptHash),
-      assetClassToUnit(multisigUtxoNft),
+      createScriptAddress(
+        lucid.config().network!,
+        sysParams.validatorHashes.interestCollectionHash,
+      ),
+      assetClassToUnit(
+        fromSystemParamsAsset(
+          sysParams.interestCollectionParams.multisigUtxoNft,
+        ),
+      ),
     ),
     (_) => new Error('Expected a single admin interest collector UTXO'),
   );
@@ -34,12 +43,19 @@ export async function findAdminInterestCollectors(
 
 export async function findRandomNonAdminInterestCollector(
   lucid: LucidEvolution,
-  interestCollectorScriptHash: string,
-  multisigUtxoNft: AssetClass,
+  sysParams: SystemParams,
 ): Promise<UTxO> {
   const allCollectors = (
-    await findAllInterestCollectors(lucid, interestCollectorScriptHash)
-  ).filter((utxo) => !assetClassValueOf(utxo.assets, multisigUtxoNft));
+    await findAllInterestCollectors(lucid, sysParams)
+  ).filter(
+    (utxo) =>
+      !assetClassValueOf(
+        utxo.assets,
+        fromSystemParamsAsset(
+          sysParams.interestCollectionParams.multisigUtxoNft,
+        ),
+      ),
+  );
 
   return F.pipe(
     O.fromNullable(getRandomElement(allCollectors)),

package/src/contracts/pyth-feed/helpers.ts

@@ -8,6 +8,30 @@ import {
 } from './types';
 import { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
 import { fromHex } from '@lucid-evolution/lucid';
+import { array as A, function as F } from 'fp-ts';
+import { BigIntOrd } from '../../utils/bigint-utils';
+
+/**
+ * Collect all unique price feed IDs in the derived price sorted ascending.
+ */
+export function collectPriceFeedIds(
+  derivedPythPrice: DerivedPythPrice,
+): bigint[] {
+  const ids = match(derivedPythPrice)
+    .with({ Value: P.select() }, (value) => [
+      BigInt(value.configuration.priceFeedId),
+    ])
+    .with({ Inverse: P.select() }, (inverse) =>
+      collectPriceFeedIds(fromDataDerivedPythPrice(inverse.value)),
+    )
+    .with({ Divide: P.select() }, (divide) => [
+      ...collectPriceFeedIds(fromDataDerivedPythPrice(divide.x)),
+      ...collectPriceFeedIds(fromDataDerivedPythPrice(divide.y)),
+    ])
+    .exhaustive();
+
+  return F.pipe(ids, A.uniq(BigIntOrd), A.sort(BigIntOrd));
+}
 
 /** Rational form { num, den } so we can do exact division (e.g. 1/0.00001 = 100000). */
 export function derivePythPrice(

package/{tests/treasury/treasury-queries.ts → src/contracts/treasury/queries.ts}

@@ -1,5 +1,4 @@
 import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { fromSystemParamsAsset, SystemParams } from '../../src';
 import { option as O, function as F } from 'fp-ts';
 import {
   AssetClass,
@@ -7,16 +6,25 @@ import {
   assetClassValueOf,
   getRandomElement,
 } from '@3rd-eye-labs/cardano-offchain-common';
+import { fromSystemParamsAsset, SystemParams } from '../../types/system-params';
 
-export async function findRandomTreasuryUtxo(
+export async function findAllTreasuryUtxos(
   lucid: LucidEvolution,
   sysParams: SystemParams,
-): Promise<UTxO> {
+): Promise<UTxO[]> {
   // We need to consider both with staking credential and without.
-  const treasuryUtxos = await lucid.utxosAt({
-    hash: sysParams.validatorHashes.treasuryHash,
+  return lucid.utxosAt({
     type: 'Script',
+    hash: sysParams.validatorHashes.treasuryHash,
   });
+}
+
+export async function findRandomTreasuryUtxo(
+  lucid: LucidEvolution,
+  sysParams: SystemParams,
+): Promise<UTxO> {
+  // We need to consider both with staking credential and without.
+  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
 
   return F.pipe(
     O.fromNullable(getRandomElement(treasuryUtxos)),
@@ -31,10 +39,7 @@ export async function findRandomTreasuryUtxoWithOnlyAda(
   sysParams: SystemParams,
 ): Promise<UTxO> {
   // We need to consider both with staking credential and without.
-  const treasuryUtxos = await lucid.utxosAt({
-    hash: sysParams.validatorHashes.treasuryHash,
-    type: 'Script',
-  });
+  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
 
   const adaOnlyTreasuryUtxos = treasuryUtxos.filter(
     (utxo) => Object.keys(utxo.assets).length == 1,
@@ -72,27 +77,13 @@ export async function findRandomTreasuryUtxoWithAsset(
   );
 }
 
-export async function findAllTreasuryUtxos(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-): Promise<UTxO[]> {
-  // We need to consider both with staking credential and without.
-  return lucid.utxosAt({
-    type: 'Script',
-    hash: sysParams.validatorHashes.treasuryHash,
-  });
-}
-
 export async function findAllTreasuryUtxosWithNonAdaAsset(
   lucid: LucidEvolution,
   sysParams: SystemParams,
   includeDaoToken: boolean = true,
 ): Promise<UTxO[]> {
   // We need to consider both with staking credential and without.
-  const treasuryUtxos = await lucid.utxosAt({
-    hash: sysParams.validatorHashes.treasuryHash,
-    type: 'Script',
-  });
+  const treasuryUtxos = await findAllTreasuryUtxos(lucid, sysParams);
 
   const treasuryUtxosWithNonAdaAsset = treasuryUtxos.filter(
     (utxo) =>

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './contracts/cdp/types-new';
 export * from './contracts/cdp/scripts';
 export * from './contracts/cdp-creator/types';
 export * from './contracts/cdp-creator/scripts';
+export * from './contracts/cdp-creator/queries';
 export * from './contracts/poll/scripts';
 export * from './contracts/collector/transactions';
 export * from './contracts/collector/types-new';
@@ -28,16 +29,18 @@ export * from './contracts/interest-collection/types';
 export * from './contracts/interest-collection/types-new';
 export * from './contracts/interest-collection/scripts';
 export * from './contracts/interest-collection/transactions';
+export * from './contracts/interest-collection/queries';
 export * from './contracts/interest-oracle/scripts';
 export * from './contracts/version-registry/types';
 export * from './contracts/version-registry/scripts';
 export * from './contracts/treasury/transactions';
 export * from './contracts/treasury/helpers';
+export * from './contracts/treasury/scripts';
+export * from './contracts/treasury/queries';
 export * from './contracts/stability-pool/helpers';
 export * from './utils/time-helpers';
 export * from './contracts/cdp/scripts';
 export * from './contracts/collector/scripts';
-export * from './contracts/treasury/scripts';
 export * from './contracts/execute/types';
 export * from './contracts/execute/types-new';
 export * from './contracts/execute/scripts';
@@ -75,9 +78,11 @@ export * from './contracts/initialize/actions';
 export * from './utils/pyth';
 export * from './contracts/pyth-feed/types';
 export * from './contracts/pyth-feed/scripts';
+export * from './contracts/pyth-feed/helpers';
 export * from './contracts/iasset/types';
 export * from './contracts/iasset/scripts';
 export * from './contracts/iasset/helpers';
+export * from './contracts/iasset/queries';
 export * from './contracts/stableswap/helpers';
 export * from './contracts/stableswap/transactions';
 export * from './contracts/stableswap/types-new';

package/tests/cdp/actions.ts

@@ -59,7 +59,7 @@ import { runFeedPriceToOracle } from '../price-oracle/actions';
 import { rationalFromInt, rationalMul } from '../../src/types/rational';
 import { array as A } from 'fp-ts';
 import { sendValueTo } from '../utils';
-import { findRandomTreasuryUtxoWithAsset } from '../treasury/treasury-queries';
+import { findRandomTreasuryUtxoWithAsset } from '../../src/contracts/treasury/queries';
 
 // Selects users wallet and opens a CDP with the given initial collateral and mint amount
 export async function runOpenCdp(

package/tests/cdp/cdp-queries.ts

@@ -40,14 +40,13 @@ import { findPriceOracle } from '../price-oracle/price-oracle-queries';
 import { findInterestOracle } from '../queries/interest-oracle-queries';
 import { findRandomCollector } from '../queries/collector-queries';
 import { findGov } from '../gov/governance-queries';
-import { findRandomTreasuryUtxoWithOnlyAda } from '../treasury/treasury-queries';
+import { findRandomTreasuryUtxoWithOnlyAda } from '../../src/contracts/treasury/queries';
 import { parsePriceOracleDatum } from '../../src/contracts/price-oracle/types-new';
 import {
   CollateralAssetOutput,
   IAssetOutput,
 } from '../../src/contracts/iasset/types';
-import { findRandomNonAdminInterestCollector } from '../interest-collection/interest-collector-queries';
-import { LucidContext } from '../test-helpers';
+import { findRandomNonAdminInterestCollector } from '../../src/contracts/interest-collection/queries';
 import { Rational } from '../../src/types/rational';
 
 export async function findAllActiveCdps(
@@ -245,24 +244,6 @@ export async function findRandomCdpCreator(
   );
 }
 
-export async function findRandomCdpCreatorNew(
-  context: LucidContext,
-  sysParams: SystemParams,
-): Promise<UTxO> {
-  const cdpCreatorUtxos = await findAllCdpCreators(
-    context.lucid,
-    sysParams.validatorHashes.cdpCreatorHash,
-    fromSystemParamsAsset(sysParams.cdpCreatorParams.cdpCreatorNft),
-  );
-
-  return F.pipe(
-    O.fromNullable(getRandomElement(cdpCreatorUtxos)),
-    O.match(() => {
-      throw new Error('Expected some cdp creator UTXOs.');
-    }, F.identity),
-  );
-}
-
 export function findPriceOracleFromCollateralAsset(
   lucid: LucidEvolution,
   collateralAsset: CollateralAssetOutput,
@@ -329,8 +310,7 @@ export async function findAllNecessaryOrefs(
     ),
     interestCollectorUtxo: await findRandomNonAdminInterestCollector(
       lucid,
-      sysParams.validatorHashes.interestCollectionHash,
-      fromSystemParamsAsset(sysParams.interestCollectionParams.multisigUtxoNft),
+      sysParams,
     ),
     govUtxo: (
       await findGov(

package/tests/cdp/transactions-mutated.ts

@@ -75,7 +75,7 @@ import { AssetInfo } from '../endpoints/initialize';
 import { LucidContext } from '../test-helpers';
 import { option as O, function as F } from 'fp-ts';
 import { findPriceOracle } from '../price-oracle/price-oracle-queries';
-import { findRandomNonAdminInterestCollector } from '../interest-collection/interest-collector-queries';
+import { findRandomNonAdminInterestCollector } from '../../src/contracts/interest-collection/queries';
 import {
   serialiseCDPCreatorDatum,
   serialiseCDPCreatorRedeemer,
@@ -84,7 +84,7 @@ import {
   CollectInterestVariation,
   testCollectInterest,
 } from '../interest-collection/transactions-mutated';
-import { findRandomTreasuryUtxoWithOnlyAda } from '../treasury/treasury-queries';
+import { findRandomTreasuryUtxoWithOnlyAda } from '../../src/contracts/treasury/queries';
 import {
   Rational,
   rationalFloor,
@@ -909,8 +909,7 @@ export async function runTestAdjustCdpDelisted(
 
   const interestCollectorUtxo = await findRandomNonAdminInterestCollector(
     context.lucid,
-    sysParams.validatorHashes.interestCollectionHash,
-    fromSystemParamsAsset(sysParams.interestCollectionParams.multisigUtxoNft),
+    sysParams,
   );
 
   const validateFrom = slotToUnixTime(network, context.emulator.slot - 1);