@indigo-labs/indigo-sdk 0.2.42 → 0.3.0

package/tests/mock/protocol-params-mock.ts

@@ -0,0 +1,21 @@
+import { fromHex } from '@lucid-evolution/lucid';
+import { ProtocolParams } from '../../src/contracts/gov/types-new';
+
+export const protocolParamsMock: ProtocolParams = {
+  effectiveDelay: 1_000n,
+  expirationPeriod: 360_000n,
+  proposalDeposit: 1_000n,
+  proposingPeriod: 100_000n,
+  votingPeriod: 1000_000n,
+  totalShards: 4n,
+  minimumQuorum: 100_000n,
+  maxTreasuryLovelaceSpend: 10_000_000n,
+  maxTreasuryIndySpend: 10_000_000n,
+  cdpRedemptionRequiredSignature: null,
+  electorate: 35_000_000_000_000n,
+  foundationMultisig: {
+    Signature: {
+      keyHash: fromHex(''),
+    },
+  },
+};

package/tests/price-oracle/actions.ts

@@ -0,0 +1,163 @@
+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 { unixTimeToSlot } from '@lucid-evolution/lucid';
+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!,
+      context.emulator.slot,
+    ),
+  );
+
+  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!,
+      context.emulator.slot,
+    ),
+  );
+
+  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 = unixTimeToSlot(
+        context.lucid.config().network!,
+        Number(oracle.expirationTime),
+      );
+
+      if (targetSlot > context.emulator.slot) {
+        expect(targetSlot).toBeGreaterThan(context.emulator.slot);
+
+        context.emulator.awaitSlot(targetSlot - context.emulator.slot + 5);
+      }
+    })
+    // otherwise no need to await
+    .otherwise(() => {});
+}

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

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

@@ -0,0 +1,240 @@
+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,
+      context.emulator.slot,
+    );
+
+    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,
+      context.emulator.slot,
+    );
+
+    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
+
+    const feedTx = await feedPriceOracleTx(
+      context.lucid,
+      { txHash: startTxHash, outputIndex: 0 },
+      rationalFromInt(2n),
+      params,
+      context.emulator.slot,
+    );
+
+    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,
+      context.emulator.slot,
+    );
+
+    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
+
+    await expectScriptFailure(
+      'Price must be positive',
+      feedPriceOracleTx(
+        context.lucid,
+        { txHash: startTxHash, outputIndex: 0 },
+        rationalFromInt(-2n),
+        params,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  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,
+      context.emulator.slot,
+    );
+
+    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
+
+    await expectScriptFailure(
+      'Wrong continuing output',
+      feedPriceOracleTxStealNft(
+        context.lucid,
+        { txHash: startTxHash, outputIndex: 0 },
+        rationalFromInt(2n),
+        params,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  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,
+      context.emulator.slot,
+    );
+
+    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,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  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,
+      context.emulator.slot,
+    );
+
+    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,
+        context.emulator.slot,
+      ),
+    );
+  });
+
+  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,
+      context.emulator.slot,
+    );
+
+    const startTxHash = await runAndAwaitTxBuilder(context.lucid, startTx);
+
+    await runAndAwaitTx(
+      context.lucid,
+      feedPriceOracleTx(
+        context.lucid,
+        { txHash: startTxHash, outputIndex: 0 },
+        rationalFromInt(1n),
+        params,
+        context.emulator.slot,
+        Core.Data.fromCBORHex(
+          'd8799f1b0180e51d1ae19514d8799f1a00030d40ff1b00000194ce33c598ff',
+        ),
+      ),
+    );
+  });
+});

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

@@ -0,0 +1,62 @@
+import {
+  Data,
+  LucidEvolution,
+  OutRef,
+  slotToUnixTime,
+  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,
+  currentSlot: number,
+): Promise<TxBuilder> {
+  const network = lucid.config().network!;
+  const currentTime = BigInt(slotToUnixTime(network, 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

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

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