@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/price-oracle/actions.ts

@@ -1,161 +0,0 @@
-import {
-  AssetClass,
-  getInlineDatumOrThrow,
-  isSameAssetClass,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { AssetInfo, fromSystemParamsAsset, SystemParams } from '../../src';
-import {
-  LucidContext,
-  runAndAwaitTx,
-  selectWalletByAddress,
-} from '../test-helpers';
-import {
-  findAllNecessaryOrefs,
-  findPrice,
-  findPriceOracleFromCollateralAsset,
-} from '../cdp/cdp-queries';
-import { feedPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
-import { findCollateralAsset } from '../queries/iasset-queries';
-import { findPriceOracle } from './price-oracle-queries';
-import { match, P } from 'ts-pattern';
-import { parsePriceOracleDatum } from '../../src/contracts/price-oracle/types-new';
-import { expect } from 'vitest';
-import { Rational } from '../../src/types/rational';
-
-/**
- * Selects admin wallet and feeds the price oracle with the given price
- */
-export async function runFeedPriceToOracle(
-  context: LucidContext,
-  sysParams: SystemParams,
-  assetInfo: AssetInfo,
-  collateralAsset: AssetClass,
-  price: Rational,
-): Promise<void> {
-  const prevAddr = await context.lucid.wallet().address();
-
-  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-
-  const collateralOut = await findCollateralAsset(
-    context.lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpParams.collateralAssetAuthToken),
-    assetInfo.iassetTokenNameAscii,
-    collateralAsset,
-  );
-
-  const collateralInfo = assetInfo.collateralAssets.find((a) =>
-    isSameAssetClass(a.collateralAsset, collateralAsset),
-  );
-
-  if (!collateralInfo) {
-    throw new Error('No such collateral asset for the given iasset.');
-  }
-
-  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
-    context.lucid,
-    collateralOut,
-  );
-
-  await runAndAwaitTx(
-    context.lucid,
-    feedPriceOracleTx(
-      context.lucid,
-      priceOracleUtxo!,
-      price,
-      collateralInfo.oracleParams!,
-    ),
-  );
-
-  selectWalletByAddress(context, prevAddr);
-}
-
-/**
- * When oracle expired, refreshing updates the expiration leaving the same price.
- */
-export async function refreshPriceOracle(
-  context: LucidContext,
-  sysParams: SystemParams,
-  assetInfo: AssetInfo,
-  collateralAsset: AssetClass,
-): Promise<void> {
-  const prevAddr = await context.lucid.wallet().address();
-
-  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-
-  // Feed price oracle
-  const orefs = await findAllNecessaryOrefs(
-    context.lucid,
-    sysParams,
-    assetInfo.iassetTokenNameAscii,
-    collateralAsset,
-  );
-
-  const collateralInfo = assetInfo.collateralAssets.find((a) =>
-    isSameAssetClass(a.collateralAsset, collateralAsset),
-  );
-
-  if (!collateralInfo) {
-    throw new Error('No such collateral asset for the given iasset.');
-  }
-
-  const price = await findPrice(
-    context.lucid,
-    sysParams,
-    assetInfo.iassetTokenNameAscii,
-    collateralAsset,
-  );
-
-  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
-    context.lucid,
-    orefs.collateralAsset,
-  );
-
-  await runAndAwaitTx(
-    context.lucid,
-    feedPriceOracleTx(
-      context.lucid,
-      priceOracleUtxo!,
-      price,
-      collateralInfo.oracleParams!,
-    ),
-  );
-
-  selectWalletByAddress(context, prevAddr);
-}
-
-export async function waitForOracleExpiration(
-  context: LucidContext,
-  sysParams: SystemParams,
-  iasset: string,
-  collateralAsset: AssetClass,
-): Promise<void> {
-  const collateral = await findCollateralAsset(
-    context.lucid,
-    sysParams,
-    fromSystemParamsAsset(sysParams.cdpCreatorParams.collateralAssetAuthTk),
-    iasset,
-    collateralAsset,
-  );
-
-  await match(collateral.datum.priceInfo)
-    .with({ OracleNft: P.select() }, async (nft) => {
-      const priceOracle = await findPriceOracle(context.lucid, nft);
-
-      const oracle = parsePriceOracleDatum(getInlineDatumOrThrow(priceOracle));
-
-      const targetSlot = context.lucid.unixTimeToSlot(
-        Number(oracle.expirationTime),
-      );
-
-      if (targetSlot > context.lucid.currentSlot()) {
-        expect(targetSlot).toBeGreaterThan(context.lucid.currentSlot());
-
-        context.emulator.awaitSlot(
-          targetSlot - context.lucid.currentSlot() + 5,
-        );
-      }
-    })
-    // otherwise no need to await
-    .otherwise(() => {});
-}

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

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

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

@@ -1,228 +0,0 @@
-import {
-  addAssets,
-  Emulator,
-  EmulatorAccount,
-  generateEmulatorAccount,
-  Lucid,
-  paymentCredentialOf,
-} from '@lucid-evolution/lucid';
-import { beforeEach, describe, test } from 'vitest';
-import {
-  LucidContext,
-  runAndAwaitTx,
-  runAndAwaitTxBuilder,
-} from '../test-helpers';
-import { mkLovelacesOf } from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  feedPriceOracleTx,
-  PriceOracleParams,
-  startPriceOracleTx,
-} from '../../src';
-import { expectScriptFailure } from '../utils/asserts';
-import { feedPriceOracleTxStealNft } from './transactions-mutated';
-import * as Core from '@evolution-sdk/evolution';
-import { rationalFromInt } from '../../src/types/rational';
-
-type MyContext = LucidContext<{
-  admin: EmulatorAccount;
-}>;
-
-describe('Rational Price Oracle', () => {
-  beforeEach<MyContext>(async (context: MyContext) => {
-    context.users = {
-      admin: generateEmulatorAccount(
-        addAssets(mkLovelacesOf(100_000_000_000_000n)),
-      ),
-    };
-
-    context.emulator = new Emulator(Object.values(context.users));
-    context.lucid = await Lucid(context.emulator, 'Custom');
-    context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
-  });
-
-  test<MyContext>('Start Rational Price Oracle', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [tx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    await runAndAwaitTxBuilder(context.lucid, tx);
-  });
-
-  test<MyContext>('Feed Rational Price Oracle', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    const feedTx = await feedPriceOracleTx(
-      context.lucid,
-      { txHash: startTxHash, outputIndex: 0 },
-      rationalFromInt(2n),
-      params,
-    );
-
-    await runAndAwaitTxBuilder(context.lucid, feedTx);
-  });
-
-  test<MyContext>('Feed Rational Price Oracle cannot be negative', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    await expectScriptFailure(
-      'Price must be positive',
-      feedPriceOracleTx(
-        context.lucid,
-        { txHash: startTxHash, outputIndex: 0 },
-        rationalFromInt(-2n),
-        params,
-      ),
-    );
-  });
-
-  test<MyContext>('Feed Rational Price Oracle cannot be steal NFT', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    await expectScriptFailure(
-      'Wrong continuing output',
-      feedPriceOracleTxStealNft(
-        context.lucid,
-        { txHash: startTxHash, outputIndex: 0 },
-        rationalFromInt(2n),
-        params,
-      ),
-    );
-  });
-
-  test<MyContext>('Feed Rational Price Oracle cannot have zero denominator', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    await expectScriptFailure(
-      'Denominator cannot be zero',
-      feedPriceOracleTx(
-        context.lucid,
-        { txHash: startTxHash, outputIndex: 0 },
-        { numerator: 2n, denominator: 0n },
-        params,
-      ),
-    );
-  });
-
-  test<MyContext>('Feed Rational Price Oracle with large number', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    await runAndAwaitTx(
-      context.lucid,
-      feedPriceOracleTx(
-        context.lucid,
-        { txHash: startTxHash, outputIndex: 0 },
-        {
-          numerator:
-            BigInt(Number.MAX_SAFE_INTEGER) * BigInt(Number.MAX_SAFE_INTEGER),
-          denominator: BigInt(Number.MAX_SAFE_INTEGER),
-        },
-        params,
-      ),
-    );
-  });
-
-  test<MyContext>('Feed Rational Price Oracle can change auxiliary data', async (context: MyContext) => {
-    const pkh = paymentCredentialOf(context.users.admin.address).hash;
-    const params: PriceOracleParams = {
-      owner: pkh,
-      biasTime: 20_000n,
-      expirationPeriod: 1_800_000n,
-    };
-    const [startTx, _] = await startPriceOracleTx(
-      context.lucid,
-      'ORACLE_NFT',
-      rationalFromInt(1n),
-      params,
-    );
-
-    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
-
-    await runAndAwaitTx(
-      context.lucid,
-      feedPriceOracleTx(
-        context.lucid,
-        { txHash: startTxHash, outputIndex: 0 },
-        rationalFromInt(1n),
-        params,
-
-        Core.Data.fromCBORHex(
-          'd8799f1b0180e51d1ae19514d8799f1a00030d40ff1b00000194ce33c598ff',
-        ),
-      ),
-    );
-  });
-});

package/tests/price-oracle/transactions-mutated.ts

@@ -1,59 +0,0 @@
-import {
-  Data,
-  LucidEvolution,
-  OutRef,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  serialisePriceOracleDatum,
-  serialisePriceOracleRedeemer,
-} from '../../src/contracts/price-oracle/types-new';
-import { PriceOracleParams } from '../../src/contracts/price-oracle/types';
-import { mkPriceOracleValidator } from '../../src/contracts/price-oracle/scripts';
-import { matchSingle } from '../../src/utils/utils';
-import { ONE_SECOND } from '../../src/utils/time-helpers';
-import * as Core from '@evolution-sdk/evolution';
-import { mkLovelacesOf } from '@3rd-eye-labs/cardano-offchain-common';
-import { Rational } from '../../src/types/rational';
-
-export async function feedPriceOracleTxStealNft(
-  lucid: LucidEvolution,
-  oracleOref: OutRef,
-  newPrice: Rational,
-  oracleParams: PriceOracleParams,
-): Promise<TxBuilder> {
-  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
-
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([oracleOref]),
-    (_) => new Error('Expected a single price oracle UTXO'),
-  );
-
-  const oracleValidator = mkPriceOracleValidator(oracleParams);
-
-  return lucid
-    .newTx()
-    .validFrom(Number(currentTime - oracleParams.biasTime) + ONE_SECOND)
-    .validTo(Number(currentTime + oracleParams.biasTime) - ONE_SECOND)
-    .attach.SpendingValidator(oracleValidator)
-    .collectFrom(
-      [priceOracleUtxo],
-      serialisePriceOracleRedeemer({
-        currentTime: currentTime,
-        newPrice: newPrice,
-      }),
-    )
-    .pay.ToContract(
-      priceOracleUtxo.address,
-      {
-        kind: 'inline',
-        value: serialisePriceOracleDatum({
-          price: newPrice,
-          expirationTime: currentTime + oracleParams.expirationPeriod,
-          auxiliaryData: Core.Data.fromCBORHex(Data.void()),
-        }),
-      },
-      mkLovelacesOf(5_000_000n),
-    )
-    .addSignerKey(oracleParams.owner);
-}

package/tests/pyth/endpoints.ts

@@ -1,96 +0,0 @@
-import {
-  credentialToAddress,
-  credentialToRewardAddress,
-  fromHex,
-  fromText,
-  LucidEvolution,
-  validatorToScriptHash,
-} from '@lucid-evolution/lucid';
-import {
-  PythStateDatum,
-  serialisePythStateDatum,
-} from '../../src/contracts/pyth-feed/types';
-import { alwaysSucceedValidator } from '../always-succeed/script';
-import { runAndAwaitTxBuilder } from '../test-helpers';
-import { AssetClass, mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
-import { mintOneTimeToken } from '../../src';
-
-export const TEST_TRUSTED_SIGNER_PRIV_KEY =
-  'a8e6c4d187e6247719cf45112917094c6973d2cf5a5f2e9f3a6802543e523239';
-export const TEST_TRUSTED_SIGNER_PUB_KEY =
-  '4a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71f';
-
-// For the purpose of testing Pyth in an emulated environment, we need to initialize a Pyth State NFT
-// This NFT will be sent to an always succeeds validator that will have the "Pyth State" datum
-// The important part is that the Pyth State includes an always succeeds withdraw script and a
-// trusted signer that we can use to validate the Pyth Messages we generate.
-export async function initPyth(lucid: LucidEvolution): Promise<AssetClass> {
-  const pythStateName = fromText('Pyth State');
-  const pythStatePolicyId = await mintOneTimeToken(lucid, pythStateName, 1n);
-  const pythStateAsset = {
-    currencySymbol: fromHex(pythStatePolicyId),
-    tokenName: fromHex(pythStateName),
-  };
-
-  const alwaysSucceedsValidatorHash = validatorToScriptHash(
-    alwaysSucceedValidator,
-  );
-  const pythStateDatum: PythStateDatum = {
-    // The governance doesn't matter for the purpose of testing, so we can use any values
-    governance: {
-      wormhole: fromHex(''),
-      emitterChain: 0n,
-      emitterAddress: fromHex(''),
-      seenSequence: 0n,
-    },
-    trustedSigners: new Map([
-      [
-        fromHex(TEST_TRUSTED_SIGNER_PUB_KEY),
-        {
-          lower_bound: {
-            bound_type: {
-              _tag: 'NegativeInfinity',
-            },
-            is_inclusive: true,
-          },
-          upper_bound: {
-            bound_type: {
-              _tag: 'PositiveInfinity',
-            },
-            is_inclusive: true,
-          },
-        },
-      ],
-    ]),
-    deprecatedWithdrawScripts: new Map(),
-    // For the purpose of testing, we use the always succeeds validator to validate the Pyth Messages.
-    // This means the message signature checking will always succeed for the purpose of emulation testing.
-    withdraw_script: fromHex(alwaysSucceedsValidatorHash),
-  };
-
-  await runAndAwaitTxBuilder(
-    lucid,
-    lucid.newTx().pay.ToContract(
-      credentialToAddress(lucid.config().network!, {
-        hash: validatorToScriptHash(alwaysSucceedValidator),
-        type: 'Script',
-      }),
-      { kind: 'inline', value: serialisePythStateDatum(pythStateDatum) },
-      mkAssetsOf(pythStateAsset, 1n),
-      alwaysSucceedValidator,
-    ),
-  );
-
-  // Register the stake key for always succeeds validator.
-  await runAndAwaitTxBuilder(
-    lucid,
-    lucid.newTx().register.Stake(
-      credentialToRewardAddress(lucid.config().network!, {
-        hash: validatorToScriptHash(alwaysSucceedValidator),
-        type: 'Script',
-      }),
-    ),
-  );
-
-  return pythStateAsset;
-}

package/tests/pyth/helpers.ts

@@ -1,37 +0,0 @@
-import { fromHex } from '@lucid-evolution/lucid';
-import { ParsedFeedPayload } from '@pythnetwork/pyth-lazer-sdk';
-import {
-  encodePriceUpdate,
-  encodePythMessage,
-  type PythMessageParts,
-} from '../../src/utils/pyth';
-import {
-  TEST_TRUSTED_SIGNER_PRIV_KEY,
-  TEST_TRUSTED_SIGNER_PUB_KEY,
-} from './endpoints';
-
-/**
- * Creates a signed Pyth message from a list of price feeds.
- * Uses the test trusted signer keys for signing.
- */
-export async function createPythMessage(
-  feeds: ParsedFeedPayload[],
-  timestampUs: bigint,
-  channelId = 0,
-): Promise<Uint8Array> {
-  const noble = await import('@noble/ed25519');
-  const payload = encodePriceUpdate({
-    timestampUs: timestampUs.toString(),
-    channelId,
-    priceFeeds: feeds,
-  });
-  const parts: PythMessageParts = {
-    signature: await noble.signAsync(
-      payload,
-      fromHex(TEST_TRUSTED_SIGNER_PRIV_KEY),
-    ),
-    publicKey: fromHex(TEST_TRUSTED_SIGNER_PUB_KEY),
-    payload,
-  };
-  return encodePythMessage(parts);
-}