@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/script-size.test.ts

@@ -1,240 +0,0 @@
-import { beforeEach, describe, test } from 'vitest';
-import {
-  loadSystemParamsFromFile,
-  mkCDPCreatorValidatorFromSP,
-  mkCdpValidatorFromSP,
-  mkCollectorValidatorFromSP,
-  mkExecuteValidatorFromSP,
-  mkRobValidatorFromSP,
-  mkPollManagerValidatorFromSP,
-  mkPollShardValidatorFromSP,
-  mkVersionRegistryValidator,
-} from '../src';
-import { LucidContext } from './test-helpers';
-import {
-  Emulator,
-  EmulatorAccount,
-  Lucid,
-  LucidEvolution,
-  SpendingValidator,
-  TxBuilder,
-  credentialToAddress,
-  fromHex,
-  generateEmulatorAccount,
-} from '@lucid-evolution/lucid';
-import { benchmarkAndAwaitTx } from './utils/benchmark-utils';
-import { mkGovValidatorFromSP } from '../src/contracts/gov/scripts';
-import { mkStabilityPoolValidatorFromSP } from '../src/contracts/stability-pool/scripts';
-import { mkStakingValidatorFromSP } from '../src/contracts/staking/scripts';
-import { mkTreasuryValidatorFromSP } from '../src/contracts/treasury/scripts';
-import { mkStableswapValidatorFromSP } from '../src/contracts/stableswap/scripts';
-import { mkPythFeedValidator } from '../src/contracts/pyth-feed/scripts';
-import { MAINNET_PROTOCOL_PARAMETERS } from './indigo-test-helpers';
-
-const systemParams = loadSystemParamsFromFile(
-  './tests/data/system-params.json',
-);
-
-type TestContext = LucidContext<{
-  admin: EmulatorAccount;
-}>;
-
-describe('Script Size', () => {
-  function initScriptRef(
-    lucid: LucidEvolution,
-    validator: SpendingValidator,
-  ): TxBuilder {
-    return lucid.newTx().pay.ToContract(
-      credentialToAddress(lucid.config().network!, {
-        hash: 'ea84d625650d066e1645e3e81d9c70a73f9ed837bd96dc49850ae744', // always fail validator hash
-        type: 'Script',
-      }),
-      undefined,
-      undefined,
-      validator,
-    );
-  }
-
-  beforeEach<TestContext>(async (context: TestContext) => {
-    context.users = {
-      admin: generateEmulatorAccount({
-        lovelace: BigInt(100_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('CDP Creator', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - CDP Creator',
-      initScriptRef(
-        context.lucid,
-        mkCDPCreatorValidatorFromSP(systemParams.cdpCreatorParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('CDP', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - CDP',
-      initScriptRef(
-        context.lucid,
-        mkCdpValidatorFromSP(systemParams.cdpParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Collector', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Collector',
-      initScriptRef(
-        context.lucid,
-        mkCollectorValidatorFromSP(systemParams.collectorParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Execute', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Execute',
-      initScriptRef(
-        context.lucid,
-        mkExecuteValidatorFromSP(systemParams.executeParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Gov', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Gov',
-      initScriptRef(
-        context.lucid,
-        mkGovValidatorFromSP(systemParams.govParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('ROB', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - ROB',
-      initScriptRef(
-        context.lucid,
-        mkRobValidatorFromSP(systemParams.robParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Poll Manager', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Poll Manager',
-      initScriptRef(
-        context.lucid,
-        mkPollManagerValidatorFromSP(systemParams.pollManagerParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Poll Shard', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Poll Shard',
-      initScriptRef(
-        context.lucid,
-        mkPollShardValidatorFromSP(systemParams.pollShardParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Pyth Feed', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Pyth Feed',
-      initScriptRef(
-        context.lucid,
-        mkPythFeedValidator({
-          config: { Value: { configuration: { priceFeedId: 0n } } },
-          pythStatePolicyId: fromHex(''),
-        }),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Stability Pool', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Stability Pool',
-      initScriptRef(
-        context.lucid,
-        mkStabilityPoolValidatorFromSP(systemParams.stabilityPoolParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Stableswap', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Stableswap',
-      initScriptRef(
-        context.lucid,
-        mkStableswapValidatorFromSP(systemParams.stableswapParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Staking', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Staking',
-      initScriptRef(
-        context.lucid,
-        mkStakingValidatorFromSP(systemParams.stakingParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Treasury', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Treasury',
-      initScriptRef(
-        context.lucid,
-        mkTreasuryValidatorFromSP(systemParams.treasuryParams),
-      ),
-      context.lucid,
-      context.emulator,
-    );
-  });
-
-  test('Version Registry', async (context: TestContext) => {
-    await benchmarkAndAwaitTx(
-      'Script Size - Version Registry',
-      initScriptRef(context.lucid, mkVersionRegistryValidator()),
-      context.lucid,
-      context.emulator,
-    );
-  });
-});

package/tests/setup.ts

@@ -1,135 +0,0 @@
-import { BenchmarkResult } from './utils/benchmark-utils';
-import { writeFileSync, readFileSync, existsSync, unlinkSync } from 'fs';
-import { join } from 'path';
-
-// File path to persist benchmark results across workers
-const BENCHMARK_RESULTS_FILE = join(
-  process.cwd(),
-  '.vitest-benchmark-results.json',
-);
-
-// Parse command-line arguments for --benchmark-file flag
-function getBenchmarkOutputFile(): string | null {
-  const args = process.argv;
-  const flagIndex = args.indexOf('--benchmark-file');
-  if (flagIndex !== -1 && flagIndex + 1 < args.length) {
-    return args[flagIndex + 1];
-  }
-  return null;
-}
-
-// Helper function to read results from file
-function readResultsFromFile(): Record<string, BenchmarkResult> {
-  if (existsSync(BENCHMARK_RESULTS_FILE)) {
-    try {
-      const content = readFileSync(BENCHMARK_RESULTS_FILE, 'utf-8');
-      return JSON.parse(content) as Record<string, BenchmarkResult>;
-    } catch (error) {
-      console.warn('Failed to read benchmark results file:', error);
-      return {};
-    }
-  }
-  return {};
-}
-
-// Helper function to write results to file
-function writeResultsToFile(results: Record<string, BenchmarkResult>): void {
-  try {
-    writeFileSync(
-      BENCHMARK_RESULTS_FILE,
-      JSON.stringify(results, null, 2),
-      'utf-8',
-    );
-  } catch (error) {
-    console.warn('Failed to write benchmark results file:', error);
-  }
-}
-
-// In-memory store for the current worker/test file
-// Using a Proxy to automatically sync to file when properties are set
-const _BENCHMARK_RESULTS: Record<string, BenchmarkResult> = {};
-
-// Create a Proxy that automatically syncs to file on property assignment
-export const BENCHMARK_RESULTS = new Proxy(_BENCHMARK_RESULTS, {
-  set(target, property, value: BenchmarkResult) {
-    if (Object.prototype.hasOwnProperty.call(target, property)) {
-      throw new Error(
-        `Benchmark with name "${property as string}" already exists.`,
-      );
-    }
-
-    // Set the value in the local object
-    target[property as string] = value;
-
-    // Merge with existing results from file and write back
-    const existingResults = readResultsFromFile();
-    const mergedResults = { ...existingResults, ...target };
-    writeResultsToFile(mergedResults);
-
-    return true;
-  },
-  get(target, property) {
-    // When reading, first merge with file results to get latest from other workers
-    const fileResults = readResultsFromFile();
-    Object.assign(target, fileResults);
-    return target[property as string];
-  },
-});
-
-// Vitest global setup (must be default export)
-export default function setup() {
-  // Clear any existing results file at the start
-  if (existsSync(BENCHMARK_RESULTS_FILE)) {
-    unlinkSync(BENCHMARK_RESULTS_FILE);
-  }
-
-  // Return teardown function
-  return function teardown() {
-    // Read all results from file (accumulated across all workers)
-    const results = readResultsFromFile();
-
-    if (Object.keys(results).length === 0) {
-      return;
-    }
-
-    // Sort entries by benchmark name alphabetically
-    const sortedEntries = Object.entries(results).sort(([a], [b]) =>
-      a.localeCompare(b),
-    );
-
-    const decimalPlaces = 3;
-
-    console.log('\n=== Benchmark Results ===');
-    console.table(
-      sortedEntries.map(([name, result]: [string, BenchmarkResult]) => ({
-        'Benchmark Name': name,
-        'Memory Percentage': result.memPercentage.toFixed(decimalPlaces) + '%',
-        'Steps Percentage': result.stepsPercentage.toFixed(decimalPlaces) + '%',
-        'Size Percentage': result.sizePercentage.toFixed(decimalPlaces) + '%',
-      })),
-    );
-
-    // Write results to output file if --benchmark-file flag is present
-    const outputFile = getBenchmarkOutputFile();
-    if (outputFile) {
-      try {
-        writeFileSync(
-          outputFile,
-          JSON.stringify(Object.fromEntries(sortedEntries), null, 2),
-          'utf-8',
-        );
-        console.log(`\nBenchmark results written to: ${outputFile}`);
-      } catch (error) {
-        console.warn(
-          `Failed to write benchmark results to ${outputFile}:`,
-          error,
-        );
-      }
-    }
-
-    // Clean up the results file
-    if (existsSync(BENCHMARK_RESULTS_FILE)) {
-      unlinkSync(BENCHMARK_RESULTS_FILE);
-    }
-  };
-}

package/tests/stability-pool/actions.ts

@@ -1,229 +0,0 @@
-import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
-import {
-  fromHex,
-  fromText,
-  LucidEvolution,
-  TxBuilder,
-} from '@lucid-evolution/lucid';
-import {
-  addrDetails,
-  requestSpAccountAdjustment,
-  bigintMax,
-  requestSpAccountClosure,
-  createE2s2sSnapshots,
-  requestSpAccountCreation,
-  fromSystemParamsAsset,
-  openCdp,
-  processSpRequest,
-  SystemParams,
-  findStabilityPool,
-  findStabilityPoolAccount,
-  findE2s2sSnapshots,
-} from '../../src';
-import {
-  findAllNecessaryOrefs,
-  findPriceOracleFromCollateralAsset,
-} from '../cdp/cdp-queries';
-
-import { LucidContext, runAndAwaitTx } from '../test-helpers';
-import { expect } from 'vitest';
-import { findIAsset } from '../queries/iasset-queries';
-import {
-  rationalCeil,
-  rationalDiv,
-  rationalFromInt,
-  rationalMul,
-  rationalSub,
-} from '../../src/types/rational';
-
-export async function runOpenCdpAndCreateSPAccount(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  /**
-   * The collateral asset to back the borrowed iAssets that will be used for stability pool deposit.
-   */
-  collateralAsset: AssetClass,
-  spDepositAmount: bigint,
-): Promise<TxBuilder> {
-  const orefs = await findAllNecessaryOrefs(
-    context.lucid,
-    sysParams,
-    asset,
-    collateralAsset,
-  );
-
-  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
-    context.lucid,
-    orefs.collateralAsset,
-  );
-
-  const collateral = bigintMax(
-    orefs.collateralAsset.datum.minCollateralAmt,
-    // collateralisation should be maintenance ratio * 2
-    rationalCeil(
-      rationalMul(
-        rationalFromInt(2n * spDepositAmount),
-        orefs.collateralAsset.datum.maintenanceRatio,
-      ),
-    ),
-  );
-
-  // Mint enough to match the intended SP deposit after paying debt minting fees.
-  const mintAmount = rationalCeil(
-    rationalDiv(
-      rationalFromInt(spDepositAmount),
-      rationalSub(rationalFromInt(1n), orefs.iasset.datum.debtMintingFeeRatio),
-    ),
-  );
-
-  await runAndAwaitTx(
-    context.lucid,
-    openCdp(
-      collateral,
-      BigInt(mintAmount),
-      sysParams,
-      orefs.cdpCreatorUtxo,
-      orefs.iasset.utxo,
-      orefs.collateralAsset.utxo,
-      priceOracleUtxo,
-      orefs.interestOracleUtxo,
-      orefs.treasuryUtxo,
-      context.lucid,
-    ),
-  );
-
-  return requestSpAccountCreation(
-    asset,
-    spDepositAmount,
-    sysParams,
-    context.lucid,
-  );
-}
-
-async function waitForAccountCooldown(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  // Request owner
-  pkh: string,
-) {
-  const accountUtxo = await findStabilityPoolAccount(
-    context.lucid,
-    sysParams,
-    pkh,
-    fromHex(fromText(asset)),
-  );
-
-  if (accountUtxo.datum.lastRequestProcessingTime !== 0n) {
-    const targetSlot = context.lucid.unixTimeToSlot(
-      Number(accountUtxo.datum.lastRequestProcessingTime) +
-        sysParams.stabilityPoolParams.accountProcessingCooldownMs,
-    );
-
-    if (targetSlot > context.lucid.currentSlot()) {
-      expect(targetSlot).toBeGreaterThan(context.lucid.currentSlot());
-
-      context.emulator.awaitSlot(targetSlot - context.lucid.currentSlot() + 2);
-    }
-  }
-}
-
-export async function runProcessSpRequest(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-  // Request owner
-  pkh: string,
-): Promise<TxBuilder> {
-  const sp = await findStabilityPool(
-    context.lucid,
-    sysParams,
-    fromHex(fromText(asset)),
-  );
-
-  const ia = await findIAsset(
-    context.lucid,
-    sysParams.validatorHashes.iassetHash,
-    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
-    asset,
-  );
-
-  const accountUtxo = await findStabilityPoolAccount(
-    context.lucid,
-    sysParams,
-    pkh,
-    fromHex(fromText(asset)),
-  );
-
-  await waitForAccountCooldown(context, sysParams, asset, pkh);
-
-  return processSpRequest(
-    sp.utxo,
-    accountUtxo.utxo,
-    ia.utxo,
-    (
-      await findE2s2sSnapshots(
-        context.lucid,
-        sysParams,
-        fromHex(fromText(asset)),
-      )
-    ).map((res) => res.utxo),
-    sysParams,
-    context.lucid,
-  );
-}
-
-export async function runCreateAdjustRequest(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  asset: string,
-  adjustment: bigint,
-): Promise<TxBuilder> {
-  const [pkh, _] = await addrDetails(lucid);
-
-  const accountUtxo = await findStabilityPoolAccount(
-    lucid,
-    sysParams,
-    pkh.hash,
-    fromHex(fromText(asset)),
-  );
-
-  return requestSpAccountAdjustment(
-    adjustment,
-    accountUtxo.utxo,
-    sysParams,
-    lucid,
-  );
-}
-
-export async function runCreateCloseRequest(
-  lucid: LucidEvolution,
-  sysParams: SystemParams,
-  asset: string,
-): Promise<TxBuilder> {
-  const [pkh, _] = await addrDetails(lucid);
-
-  const accountUtxo = await findStabilityPoolAccount(
-    lucid,
-    sysParams,
-    pkh.hash,
-    fromHex(fromText(asset)),
-  );
-
-  return requestSpAccountClosure(accountUtxo.utxo, sysParams, lucid);
-}
-
-export async function runCreateE2s2sSnapshots(
-  context: LucidContext,
-  sysParams: SystemParams,
-  asset: string,
-): Promise<TxBuilder> {
-  const spUtxo = await findStabilityPool(
-    context.lucid,
-    sysParams,
-    fromHex(fromText(asset)),
-  );
-
-  return createE2s2sSnapshots(spUtxo.utxo, sysParams, context.lucid);
-}