@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/pyth/pyth.test.ts

@@ -1,299 +0,0 @@
-import {
-  credentialToRewardAddress,
-  Data,
-  Emulator,
-  EmulatorAccount,
-  fromHex,
-  generateEmulatorAccount,
-  Lucid,
-  scriptHashToCredential,
-  toHex,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
-import { beforeEach, describe, expect, test } from 'vitest';
-import { LucidContext, runAndAwaitTxBuilder } from '../test-helpers';
-import {
-  initPyth,
-  TEST_TRUSTED_SIGNER_PRIV_KEY,
-  TEST_TRUSTED_SIGNER_PUB_KEY,
-} from './endpoints';
-import {
-  PythFeedParams,
-  PythStateDatum,
-  serialisePythFeedRedeemer,
-  serialisePythStateDatum,
-  serialisePythUpdatesRedeemer,
-  toDataDerivedPythPrice,
-} from '../../src/contracts/pyth-feed/types';
-import { assetClassToUnit } from '@3rd-eye-labs/cardano-offchain-common';
-import { mkPythFeedValidator } from '../../src/contracts/pyth-feed/scripts';
-import { alwaysSucceedValidator } from '../always-succeed/script';
-import {
-  encodePriceUpdate,
-  encodePythMessage,
-  type PriceUpdate,
-  type PythMessageParts,
-} from '../../src/utils/pyth';
-import { MAINNET_PROTOCOL_PARAMETERS } from '../indigo-test-helpers';
-import { createPythMessage } from './helpers';
-import { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
-import { derivePythPrice } from '../../src/contracts/pyth-feed/helpers';
-import * as Core from '@evolution-sdk/evolution';
-
-type MyContext = LucidContext<{
-  admin: EmulatorAccount;
-}>;
-
-describe('Pyth > Initialization', () => {
-  beforeEach<MyContext>(async (context: MyContext) => {
-    context.users = {
-      admin: generateEmulatorAccount({
-        lovelace: BigInt(100_000_000_000_000),
-      }),
-    };
-
-    context.emulator = new Emulator(
-      [context.users.admin],
-      MAINNET_PROTOCOL_PARAMETERS,
-    );
-
-    context.lucid = await Lucid(context.emulator, 'Custom');
-    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-  });
-
-  test('initPyth initializes the Pyth State NFT', async (context: MyContext) => {
-    const pythStateAsset = await initPyth(context.lucid);
-
-    expect(pythStateAsset).toBeDefined();
-  });
-
-  test('Properly serializes a Pyth State datum', (_context: MyContext) => {
-    const pythStateDatum: PythStateDatum = {
-      governance: {
-        wormhole: fromHex(''),
-        emitterChain: 0n,
-        emitterAddress: fromHex(''),
-        seenSequence: 0n,
-      },
-      trustedSigners: new Map([
-        [
-          fromHex(
-            '4a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71f',
-          ),
-          {
-            lower_bound: {
-              bound_type: {
-                _tag: 'NegativeInfinity',
-              },
-              is_inclusive: true,
-            },
-            upper_bound: {
-              bound_type: {
-                _tag: 'Finite',
-                finite: 1n,
-              },
-              is_inclusive: true,
-            },
-          },
-        ],
-      ]),
-      deprecatedWithdrawScripts: new Map(),
-      withdraw_script: fromHex(
-        '7688145a4fa7aa18c16ef0daafeec18091ab99ea4268cfe2d863c79fda131938',
-      ),
-    };
-
-    const serialisedPythStateDatum = serialisePythStateDatum(pythStateDatum);
-    expect(serialisedPythStateDatum).toBe(
-      'd8799fd8799f40004000ffa158204a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71fd8799fd8799fd87980d87a80ffd8799fd87a9f01ffd87a80ffffa058207688145a4fa7aa18c16ef0daafeec18091ab99ea4268cfe2d863c79fda131938ff',
-    );
-  });
-
-  test('Pyth Feed validator can confirm a Pyth Message', async (context: MyContext) => {
-    const pythStateAsset = await initPyth(context.lucid);
-
-    const noble = await import('@noble/ed25519');
-    const priceFeedId = 1;
-    const price = 1000n;
-    const exponent = -8;
-
-    const params: PythFeedParams = {
-      pythStatePolicyId: pythStateAsset.currencySymbol,
-      config: {
-        Value: { configuration: { priceFeedId: BigInt(priceFeedId) } },
-      },
-    };
-
-    const pfvValidator = mkPythFeedValidator(params);
-    const pfvValHash = validatorToScriptHash(pfvValidator);
-
-    // Register the stake key for pyth feed validator.
-    await runAndAwaitTxBuilder(
-      context.lucid,
-      context.lucid.newTx().register.Stake(
-        credentialToRewardAddress(context.lucid.config().network!, {
-          hash: pfvValHash,
-          type: 'Script',
-        }),
-      ),
-    );
-
-    const currentTime = BigInt(
-      context.lucid.slotToUnixTime(context.lucid.currentSlot()),
-    );
-
-    // This is to test the transaction validity when using a timestamp different than the
-    // slot boundary (which is the usual and general case).
-    const timestamp = currentTime - 10n;
-
-    const update: PriceUpdate = {
-      timestampUs: (timestamp * 1_000n).toString(),
-      channelId: 0,
-      priceFeeds: [
-        {
-          priceFeedId,
-          price: price.toString(),
-          exponent,
-        },
-      ],
-    };
-    const payload = encodePriceUpdate(update);
-    const signature = await noble.signAsync(
-      payload,
-      fromHex(TEST_TRUSTED_SIGNER_PRIV_KEY),
-    );
-    const parts: PythMessageParts = {
-      signature,
-      publicKey: fromHex(TEST_TRUSTED_SIGNER_PUB_KEY),
-      payload,
-    };
-    const message = encodePythMessage(parts);
-
-    const pythStateUtxo = await context.lucid.utxoByUnit(
-      assetClassToUnit(pythStateAsset),
-    );
-
-    await runAndAwaitTxBuilder(
-      context.lucid,
-      context.lucid
-        .newTx()
-        .readFrom([pythStateUtxo])
-        .attach.Script(pfvValidator)
-        .validFrom(Number(timestamp))
-        .validTo(Number(timestamp) + 60 * 1000)
-        .withdraw(
-          credentialToRewardAddress(
-            context.lucid.config().network!,
-            scriptHashToCredential(pfvValHash),
-          ),
-          0n,
-          serialisePythFeedRedeemer({
-            price: {
-              numerator: 1_000n,
-              denominator: 100_000_000n,
-            },
-            auxiliaryData: Core.Data.fromCBORHex(Data.void()),
-          }),
-        )
-        .withdraw(
-          credentialToRewardAddress(
-            context.lucid.config().network!,
-            scriptHashToCredential(
-              validatorToScriptHash(alwaysSucceedValidator),
-            ),
-          ),
-          0n,
-          serialisePythUpdatesRedeemer([message]),
-        ),
-    );
-  });
-});
-
-describe('Pyth > Helper functions', () => {
-  test('derivePythPrice works', async () => {
-    const feed1: ParsedFeedPayload = {
-      priceFeedId: 1,
-      price: '1000',
-      exponent: -8,
-    };
-    const feed2: ParsedFeedPayload = {
-      priceFeedId: 2,
-      price: '99',
-      exponent: 0,
-    };
-    const feed3: ParsedFeedPayload = {
-      priceFeedId: 3,
-      price: '45',
-      exponent: 0,
-    };
-    const message = await createPythMessage(
-      [feed1, feed2, feed3],
-      BigInt(Date.now()),
-    );
-
-    // Single direct value
-    // 1000 * 10^-8 = 0.00001
-    {
-      const price = derivePythPrice(
-        {
-          Value: {
-            configuration: { priceFeedId: 1n },
-          },
-        },
-        toHex(message),
-      );
-
-      expect(price.numerator).toBe(1_000n);
-      expect(price.denominator).toBe(100_000_000n);
-    }
-
-    // Single inverse value: 1 / (1000 * 10^-8) = 1 / 0.00001 = 100000
-    {
-      const price = derivePythPrice(
-        {
-          Inverse: {
-            value: toDataDerivedPythPrice({
-              Value: {
-                configuration: {
-                  priceFeedId: 1n,
-                },
-              },
-            }),
-          },
-        },
-        toHex(message),
-      );
-
-      expect(price.numerator).toBe(100_000_000n);
-      expect(price.denominator).toBe(1_000n);
-    }
-
-    // Single divide value: 99 / 45 = 2.2
-    {
-      const price = derivePythPrice(
-        {
-          Divide: {
-            x: toDataDerivedPythPrice({
-              Value: {
-                configuration: {
-                  priceFeedId: 2n,
-                },
-              },
-            }),
-            y: toDataDerivedPythPrice({
-              Value: {
-                configuration: {
-                  priceFeedId: 3n,
-                },
-              },
-            }),
-          },
-        },
-        toHex(message),
-      );
-
-      expect(price.numerator).toBe(99n);
-      expect(price.denominator).toBe(45n);
-    }
-  });
-});

package/tests/queries/collector-queries.ts

@@ -1,27 +0,0 @@
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src';
-import { option as O, function as F } from 'fp-ts';
-import { getRandomElement } from '@3rd-eye-labs/cardano-offchain-common';
-
-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,47 +0,0 @@
-import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-import { createScriptAddress, matchSingle } from '../../src';
-import { option as O, array as A, function as F } from 'fp-ts';
-import {
-  AssetClass,
-  assetClassToUnit,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  ExecuteDatum,
-  parseExecuteDatum,
-} from '../../src/contracts/execute/types-new';
-
-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/iasset-queries.ts

@@ -1,149 +0,0 @@
-import {
-  fromText,
-  LucidEvolution,
-  ScriptHash,
-  toHex,
-  toText,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
-import { matchSingle, SystemParams } from '../../src';
-import { option as O, array as A, function as F } from 'fp-ts';
-import {
-  AssetClass,
-  assetClassToUnit,
-  isSameAssetClass,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  CollateralAssetOutput,
-  IAssetOutput,
-  parseCollateralAssetDatum,
-  parseIAssetDatum,
-} from '../../src/contracts/iasset/types';
-
-// TODO: replace with the new variant defined below
-export async function findIAsset(
-  lucid: LucidEvolution,
-  iassetScriptHash: ScriptHash,
-  iassetNft: AssetClass,
-  // Ascii encoded
-  iassetName: string,
-): Promise<IAssetOutput> {
-  const iassetUtxos = await lucid.utxosAtWithUnit(
-    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 (toHex(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,
-  );
-}
-
-// TODO: replace by the new variant defined below
-export async function findCollateralAsset(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  collateralAssetNft: AssetClass,
-  // Ascii encoded
-  iassetName: string,
-  collateralAsset: AssetClass,
-): Promise<CollateralAssetOutput> {
-  const collateralAssetUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(
-      lucid.config().network!,
-      sysParams.validatorHashes.iassetHash,
-    ),
-    assetClassToUnit(collateralAssetNft),
-  );
-
-  return matchSingle(
-    F.pipe(
-      collateralAssetUtxos.map((utxo) =>
-        F.pipe(
-          O.fromNullable(utxo.datum),
-          O.flatMap(parseCollateralAssetDatum),
-          O.flatMap((datum) => {
-            if (
-              isSameAssetClass(datum.collateralAsset, collateralAsset) &&
-              fromText(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),
-      ),
-  );
-}
-
-export async function findAllCollateralAssetsOfIAsset(
-  lucid: LucidEvolution,
-  iassetScriptHash: ScriptHash,
-  collateralAssetNft: AssetClass,
-  iasset: Uint8Array<ArrayBufferLike>,
-): Promise<CollateralAssetOutput[]> {
-  const collateralUtxos = await lucid.utxosAtWithUnit(
-    createScriptAddress(lucid.config().network!, iassetScriptHash),
-    assetClassToUnit(collateralAssetNft),
-  );
-
-  return F.pipe(
-    collateralUtxos.map((utxo) =>
-      F.pipe(
-        O.fromNullable(utxo.datum),
-        O.flatMap(parseCollateralAssetDatum),
-        O.filter(
-          (collateralAsset) =>
-            toText(toHex(collateralAsset.iasset)) === toText(toHex(iasset)),
-        ),
-        O.map((datum) => ({ utxo, datum: datum })),
-      ),
-    ),
-    A.compact,
-  );
-}

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

@@ -1,12 +0,0 @@
-import {
-  AssetClass,
-  assetClassToUnit,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { LucidEvolution, UTxO } from '@lucid-evolution/lucid';
-
-export async function findInterestOracle(
-  lucid: LucidEvolution,
-  interestNft: AssetClass,
-): Promise<UTxO> {
-  return lucid.utxoByUnit(assetClassToUnit(interestNft));
-}

package/tests/queries/poll-queries.ts

@@ -1,97 +0,0 @@
-import { LucidEvolution, ScriptHash, UTxO } from '@lucid-evolution/lucid';
-
-import { matchSingle, createScriptAddress } from '../../src';
-import { option as O, array as A, function as F } from 'fp-ts';
-import {
-  AssetClass,
-  assetClassToUnit,
-  getRandomElement,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  parsePollManager,
-  parsePollShard,
-  PollManagerContent,
-  PollShardContent,
-} from '../../src/contracts/poll/types-poll-new';
-
-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/staking-queries.ts

@@ -1,54 +0,0 @@
-import {
-  LucidEvolution,
-  ScriptHash,
-  toHex,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import { createScriptAddress } from '../../src/utils/lucid-utils';
-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 {
-  AssetClass,
-  assetClassToUnit,
-} from '@3rd-eye-labs/cardano-offchain-common';
-
-export async function findStakingPosition(
-  lucid: LucidEvolution,
-  stakingScriptHash: ScriptHash,
-  stakingPositionNft: AssetClass,
-  owner: string,
-): Promise<{ utxo: UTxO; datum: StakingPosition }> {
-  const network = lucid.config().network!;
-
-  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,
-    ),
-    (res) =>
-      new Error(
-        'Expected a single Staking Position UTXO.: ' + JSON.stringify(res),
-      ),
-  );
-}