@indigo-labs/indigo-sdk 0.2.42 → 0.3.1

package/tests/script-size.test.ts

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

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

@@ -0,0 +1,220 @@
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  LucidEvolution,
+  TxBuilder,
+  unixTimeToSlot,
+} from '@lucid-evolution/lucid';
+import {
+  addrDetails,
+  requestSpAccountAdjustment,
+  bigintMax,
+  requestSpAccountClosure,
+  createE2s2sSnapshots,
+  requestSpAccountCreation,
+  fromSystemParamsAsset,
+  openCdp,
+  processSpRequest,
+  SystemParams,
+} from '../../src';
+import {
+  findAllNecessaryOrefs,
+  findPriceOracleFromCollateralAsset,
+} from '../cdp/cdp-queries';
+import {
+  findE2s2sSnapshots,
+  findStabilityPool,
+  findStabilityPoolAccount,
+} from '../queries/stability-pool-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,
+      context.emulator.slot,
+    ),
+  );
+
+  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,
+    asset,
+  );
+
+  if (accountUtxo.datum.lastRequestProcessingTime !== 0n) {
+    const targetSlot = unixTimeToSlot(
+      context.lucid.config().network!,
+      Number(accountUtxo.datum.lastRequestProcessingTime) +
+        sysParams.stabilityPoolParams.accountProcessingCooldownMs,
+    );
+
+    if (targetSlot > context.emulator.slot) {
+      expect(targetSlot).toBeGreaterThan(context.emulator.slot);
+
+      context.emulator.awaitSlot(targetSlot - context.emulator.slot + 2);
+    }
+  }
+}
+
+export async function runProcessSpRequest(
+  context: LucidContext,
+  sysParams: SystemParams,
+  asset: string,
+  // Request owner
+  pkh: string,
+): Promise<TxBuilder> {
+  const sp = await findStabilityPool(context.lucid, sysParams, asset);
+
+  const ia = await findIAsset(
+    context.lucid,
+    sysParams.validatorHashes.iassetHash,
+    fromSystemParamsAsset(sysParams.cdpParams.iAssetAuthToken),
+    asset,
+  );
+
+  const accountUtxo = await findStabilityPoolAccount(
+    context.lucid,
+    sysParams,
+    pkh,
+    asset,
+  );
+
+  await waitForAccountCooldown(context, sysParams, asset, pkh);
+
+  return processSpRequest(
+    sp.utxo,
+    accountUtxo.utxo,
+    ia.utxo,
+    (await findE2s2sSnapshots(context.lucid, sysParams, asset)).map(
+      (res) => res.utxo,
+    ),
+    sysParams,
+    context.lucid,
+    context.emulator.slot,
+  );
+}
+
+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,
+    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,
+    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, asset);
+
+  return createE2s2sSnapshots(spUtxo.utxo, sysParams, context.lucid);
+}