@indigo-labs/indigo-sdk 0.1.21 → 0.1.23

package/tests/mock/assets-mock.ts

@@ -1,59 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/poll-queries.ts

@@ -1,97 +0,0 @@
-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/treasury-queries.ts

@@ -1,19 +0,0 @@
-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),
-  );
-}

package/tests/utils/asserts.ts

@@ -1,13 +0,0 @@
-import { assert, expect } from 'vitest';
-
-export function assertValueInRange<T extends number | bigint>(
-  val: T,
-  bounds: { min: T; max: T },
-): void {
-  assert(bounds.max > bounds.min, 'Bounds are incorrectly configured.');
-
-  expect(
-    bounds.min <= val && val <= bounds.max,
-    `${val} not in range [${bounds.min}, ${bounds.max}]`,
-  ).toBeTruthy();
-}

package/tests/utils/index.ts

@@ -1,50 +0,0 @@
-import {
-  addAssets,
-  Assets,
-  LucidEvolution,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { array as A } from 'fp-ts';
-import { negateAssets } from '../../src/utils/value-helpers';
-
-export async function getValueChangeAtAddressAfterAction<T>(
-  lucid: LucidEvolution,
-  address: string,
-  action: () => Promise<T>,
-): Promise<[T, Assets]> {
-  const valBefore = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
-    addAssets(acc, utxo.assets),
-  )(await lucid.utxosAt(address));
-
-  const res = await action();
-
-  const valAfter = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
-    addAssets(acc, utxo.assets),
-  )(await lucid.utxosAt(address));
-
-  return [res, addAssets(valAfter, negateAssets(valBefore))];
-}
-
-export async function getNewUtxosAtAddressAfterAction<T>(
-  lucid: LucidEvolution,
-  address: string,
-  action: () => Promise<T>,
-): Promise<[T, UTxO[]]> {
-  const utxosBefore = await lucid.utxosAt(address);
-
-  const res = await action();
-
-  const utxosAfter = await lucid.utxosAt(address);
-
-  return [
-    res,
-    utxosAfter.filter(
-      (utxo) =>
-        utxosBefore.filter(
-          (oldUtxo) =>
-            utxo.txHash === oldUtxo.txHash &&
-            utxo.outputIndex === oldUtxo.outputIndex,
-        ).length === 0,
-    ),
-  ];
-}