@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/test-helpers.ts

@@ -4,21 +4,46 @@ import {
   LucidEvolution,
   TxBuilder,
 } from '@lucid-evolution/lucid';
+import { AssetInfo } from '../src/contracts/initialize/types';
+import { SystemParams } from '../src';
+import { array as A, function as F, option as O } from 'fp-ts';
 
-export type LucidContext<T extends Record<string, EmulatorAccount>> = {
+type EmulatorAccountMap = Record<string, EmulatorAccount> & {
+  admin: EmulatorAccount;
+};
+
+export type LucidContext<T extends EmulatorAccountMap = EmulatorAccountMap> = {
   lucid: LucidEvolution;
   users: T;
   emulator: Emulator;
 };
 
+export type IndigoTestContext = LucidContext<{
+  admin: EmulatorAccount;
+  user: EmulatorAccount;
+  user2: EmulatorAccount;
+  withdrawalAccount: EmulatorAccount;
+}> & {
+  systemParams: SystemParams;
+  assetConfigs: readonly AssetInfo[];
+};
+
 export async function runAndAwaitTx(
   lucid: LucidEvolution,
   transaction: Promise<TxBuilder>,
+  extraSigners: string[] = [],
 ): Promise<string> {
-  const txHash = await transaction
-    .then((tx) => tx.complete())
-    .then((tx) => tx.sign.withWallet().complete())
-    .then((tx) => tx.submit());
+  const bTx = await (await transaction).complete();
+
+  const signatures = [await bTx.partialSign.withWallet()];
+  for (const signer of extraSigners) {
+    lucid.selectWallet.fromSeed(signer);
+    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
+  }
+
+  const signedTx = bTx.assemble(signatures);
+
+  const txHash = await signedTx.complete().then((tx) => tx.submit());
 
   await lucid.awaitTx(txHash);
   return txHash;
@@ -27,11 +52,19 @@ export async function runAndAwaitTx(
 export async function runAndAwaitTxBuilder(
   lucid: LucidEvolution,
   transaction: TxBuilder,
+  extraSigners: string[] = [],
 ): Promise<string> {
-  const txHash = await transaction
-    .complete()
-    .then((tx) => tx.sign.withWallet().complete())
-    .then((tx) => tx.submit());
+  const bTx = await transaction.complete();
+
+  const signatures = [await bTx.partialSign.withWallet()];
+  for (const signer of extraSigners) {
+    lucid.selectWallet.fromSeed(signer);
+    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
+  }
+
+  const signedTx = bTx.assemble(signatures);
+
+  const txHash = await signedTx.complete().then((tx) => tx.submit());
 
   await lucid.awaitTx(txHash);
   return txHash;
@@ -39,9 +72,23 @@ export async function runAndAwaitTxBuilder(
 
 export async function repeat(
   times: number,
-  action: () => Promise<void>,
+  action: (isLast: boolean, idx: number) => Promise<void>,
 ): Promise<void> {
   for (let i = 0; i < times; i++) {
-    await action();
+    await action(i === times - 1, i);
   }
 }
+
+export function selectWalletByAddress(
+  context: LucidContext,
+  addr: string,
+): void {
+  const account = F.pipe(
+    Object.values(context.users),
+    A.findFirst((account) => account.address === addr),
+    O.getOrElse<EmulatorAccount>(() => {
+      throw new Error('No such account with the given address');
+    }),
+  );
+  context.lucid.selectWallet.fromSeed(account.seedPhrase);
+}

package/tests/treasury.test.ts

@@ -0,0 +1,242 @@
+import { addAssets, Assets, TxBuilder } from '@lucid-evolution/lucid';
+import { assert, beforeEach, describe, test } from 'vitest';
+import { IndigoTestContext } from './test-helpers';
+import { treasuryCollect, treasuryMerge, treasurySplit } from '../src';
+import {
+  createIndigoTestContext,
+  EXAMPLE_TOKEN_1,
+  EXAMPLE_TOKEN_2,
+  EXAMPLE_TOKEN_3,
+} from './indigo-test-helpers';
+import { benchmarkAndAwaitTx } from './utils/benchmark-utils';
+import {
+  findAllTreasuryUtxos,
+  findRandomTreasuryUtxoWithOnlyAda,
+} from './queries/treasury-queries';
+import {
+  adaAssetClass,
+  mkLovelacesOf,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { mkAssetsOf } from '@3rd-eye-labs/cardano-offchain-common';
+import { createUtxoAtTreasury } from './endpoints/treasury';
+import { expectScriptFailure } from './utils/asserts';
+
+// NOTE: Withdrawing and PrepareWithdrawal from Treasury is tested in gov.test.ts
+describe('Treasury', () => {
+  beforeEach<IndigoTestContext>(async (context: IndigoTestContext) => {
+    await createIndigoTestContext(context);
+  });
+
+  async function treasuryMergeTx(
+    context: IndigoTestContext,
+    treasuryOutputs: Assets[],
+  ): Promise<TxBuilder> {
+    for (const output of treasuryOutputs) {
+      await createUtxoAtTreasury(output, context.systemParams, context);
+    }
+
+    const treasuryUtxos = await findAllTreasuryUtxos(
+      context.lucid,
+      context.systemParams,
+    );
+
+    // Simpler approach: for each expected output in treasuryOutputs, find one UTxO with exactly matching assets and take it
+    // Find UTxOs for each expected output, but remove it from the candidate list as we match
+    const availableUtxos = [...treasuryUtxos];
+    const matchedTreasuryUtxos = treasuryOutputs
+      .map((expectedAssets) => {
+        const idx = availableUtxos.findIndex((utxo) => {
+          const utxoAssets = utxo.assets;
+          const keys1 = Object.keys(utxoAssets).sort();
+          const keys2 = Object.keys(expectedAssets).sort();
+          if (keys1.length !== keys2.length) return false;
+          return keys1.every(
+            (k, i) => k === keys2[i] && utxoAssets[k] === expectedAssets[k],
+          );
+        });
+        if (idx !== -1) {
+          return availableUtxos.splice(idx, 1)[0];
+        } else {
+          return undefined;
+        }
+      })
+      .filter((utxo) => utxo !== undefined);
+
+    assert(
+      matchedTreasuryUtxos.length === treasuryOutputs.length,
+      'Expected all treasury outputs to be matched',
+    );
+
+    return await treasuryMerge(
+      matchedTreasuryUtxos,
+      context.lucid,
+      context.systemParams,
+    );
+  }
+
+  async function treasurySplitTx(
+    context: IndigoTestContext,
+    treasuryOutput: Assets,
+  ): Promise<TxBuilder> {
+    await createUtxoAtTreasury(treasuryOutput, context.systemParams, context);
+
+    const treasuryUtxos = await findAllTreasuryUtxos(
+      context.lucid,
+      context.systemParams,
+    );
+
+    const matchedTreasuryUtxo = treasuryUtxos.find((utxo) =>
+      Object.keys(treasuryOutput).every(
+        (key) => utxo.assets[key] === treasuryOutput[key],
+      ),
+    );
+
+    assert(
+      matchedTreasuryUtxo !== undefined,
+      'Expected a single treasury UTXO',
+    );
+
+    return await treasurySplit(
+      matchedTreasuryUtxo,
+      context.lucid,
+      context.systemParams,
+    );
+  }
+
+  test<IndigoTestContext>('Merge (3 lovelace UTxOs)', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Merge (3 lovelace UTxOs)',
+      await treasuryMergeTx(context, [
+        mkLovelacesOf(50_000_000n),
+        mkLovelacesOf(50_000_000n),
+        mkLovelacesOf(50_000_000n),
+      ]),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<IndigoTestContext>('Merge (3 INDY UTxOs)', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Merge (3 INDY UTxOs)',
+      await treasuryMergeTx(context, [
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+      ]),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<IndigoTestContext>('Merge (fail, 1 lovelace, 2 INDY UTxOs)', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await expectScriptFailure(
+      'All inputs have to contain the same merging assets',
+      treasuryMergeTx(context, [
+        mkLovelacesOf(5_000_000n),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1_000_000_000n),
+        ),
+      ]),
+    );
+  });
+
+  test<IndigoTestContext>('Split (3 assets)', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await benchmarkAndAwaitTx(
+      'Treasury - Split (3 assets)',
+      await treasurySplitTx(
+        context,
+        addAssets(
+          mkLovelacesOf(5_000_000n),
+          mkAssetsOf(EXAMPLE_TOKEN_1, 1n),
+          mkAssetsOf(EXAMPLE_TOKEN_2, 1n),
+          mkAssetsOf(EXAMPLE_TOKEN_3, 1n),
+        ),
+      ),
+      context.lucid,
+      context.emulator,
+    );
+  });
+
+  test<IndigoTestContext>('Split (fail, lovelace only)', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    await expectScriptFailure(
+      'All inputs must have more than 1 non-ADA asset or 1 non-ADA asset and more than 2x ADA buffer',
+      treasurySplitTx(context, mkLovelacesOf(5_000_000n)),
+    );
+  });
+
+  test<IndigoTestContext>('Collect non-positive amount or negative extra lovelaces fails', async (context: IndigoTestContext) => {
+    context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+    const treasuryUTxO = await findRandomTreasuryUtxoWithOnlyAda(
+      context.lucid,
+      context.systemParams,
+    );
+
+    // This tests that the amount to collect cannot be negative.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        -1_000_000n,
+        0n,
+        context.lucid,
+        context.systemParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+
+    // This tests that the amount to collect cannot be zero.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        0n,
+        0n,
+        context.lucid,
+        context.systemParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+
+    // This tests that the extra lovelaces cannot be negative.
+    await expectScriptFailure(
+      'Collected amount is positive',
+      treasuryCollect(
+        adaAssetClass,
+        1n,
+        -1_000_000n,
+        context.lucid,
+        context.systemParams,
+        treasuryUTxO,
+        treasuryUTxO,
+      ),
+    );
+  });
+});

package/tests/utils/asserts.ts

@@ -1,5 +1,42 @@
+import {
+  isAssetsZero,
+  lovelacesAmt,
+  negateAssets,
+  noAdaValue,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { addAssets, Assets, TxBuilder } from '@lucid-evolution/lucid';
+import { JSONStringify } from 'json-with-bigint';
+import { match, P } from 'ts-pattern';
 import { assert, expect } from 'vitest';
 
+export async function expectScriptFailure(
+  /**
+   * This doesn't have to be full message, can be just a part of it.
+   */
+  contains: string,
+  tx: Promise<TxBuilder>,
+): Promise<void> {
+  if (contains.length === 0) {
+    throw new Error('Expected error message has to be non empty.');
+  }
+
+  const result = await (await tx).completeSafe();
+
+  const errMsg = match(result)
+    .with({ _tag: 'Left', left: P.select() }, (smth) => smth.message)
+    .otherwise(() => null);
+
+  if (!errMsg) {
+    throw new Error(`Expected TX to fail, but it succeeded.`);
+  }
+
+  if (!errMsg.includes(contains)) {
+    throw new Error(
+      `Expected TX to fail with error containing: "${contains}". But got: "${errMsg}"`,
+    );
+  }
+}
+
 export function assertValueInRange<T extends number | bigint>(
   val: T,
   bounds: { min: T; max: T },
@@ -11,3 +48,40 @@ export function assertValueInRange<T extends number | bigint>(
     `${val} not in range [${bounds.min}, ${bounds.max}]`,
   ).toBeTruthy();
 }
+
+export function expectValue(
+  actual: Assets,
+  msg: string,
+): {
+  toEqual: (expected: Assets) => void;
+  /**
+   * The non ADA part of value has to equal and the lovelace has to be less than or equal than
+   * the expected `maxLovelace`.
+   */
+  toEqualNonAdaAndMaxAda: (constraints: {
+    expectedNonAda: Assets;
+    maxLovelace: bigint;
+  }) => void;
+} {
+  return {
+    toEqual(expected) {
+      expect(
+        isAssetsZero(addAssets(actual, negateAssets(expected))),
+        `${msg}: Expected ${JSONStringify(actual)} to equal ${JSONStringify(expected)}`,
+      ).toBeTruthy();
+    },
+    toEqualNonAdaAndMaxAda({ expectedNonAda, maxLovelace }) {
+      expect(
+        isAssetsZero(
+          addAssets(noAdaValue(actual), negateAssets(expectedNonAda)),
+        ),
+        `${msg}: Expected no ADA part of ${JSONStringify(actual)} to equal ${JSONStringify(expectedNonAda)}`,
+      ).toBeTruthy();
+
+      expect(
+        lovelacesAmt(actual),
+        `${msg}: Lovelace part is more than expected`,
+      ).toBeLessThanOrEqual(maxLovelace);
+    },
+  };
+}

package/tests/utils/benchmark-utils.ts

@@ -0,0 +1,81 @@
+import {
+  EvalRedeemer,
+  LucidEvolution,
+  Provider,
+  TxBuilder,
+  TxSignBuilder,
+} from '@lucid-evolution/lucid';
+import { array as A } from 'fp-ts';
+import { BENCHMARK_RESULTS } from '../setup';
+import { MAINNET_PROTOCOL_PARAMETERS } from '../indigo-test-helpers';
+
+type ExUnits = { mem: number; steps: number; txSize: number };
+
+export async function calculateTxExUnits(
+  provider: Provider,
+  tx: TxSignBuilder,
+): Promise<ExUnits> {
+  const cbor = tx.toCBOR();
+  const redeemersEval = await provider.evaluateTx(tx.toCBOR());
+
+  const res = A.reduce<EvalRedeemer, ExUnits>(
+    { mem: 0, steps: 0, txSize: 0 },
+    (acc, e) => {
+      return {
+        mem: acc.mem + e.ex_units.mem,
+        steps: acc.steps + e.ex_units.steps,
+        txSize: 0,
+      };
+    },
+  )(redeemersEval);
+
+  return { ...res, txSize: cbor.length / 2 };
+}
+
+export type BenchmarkResult = ExUnits & {
+  memPercentage: number;
+  stepsPercentage: number;
+  sizePercentage: number;
+};
+
+// This function is used to benchmark a transaction and await it's successful execution.
+export async function benchmarkAndAwaitTx(
+  name: string,
+  tx: TxBuilder,
+  lucid: LucidEvolution,
+  provider: Provider,
+  extraSigners: string[] = [],
+): Promise<void> {
+  // Complete the transaction
+  const bTx = await tx.complete();
+  const signatures = [await bTx.partialSign.withWallet()];
+  for (const signer of extraSigners) {
+    lucid.selectWallet.fromSeed(signer);
+    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
+  }
+
+  const signedTx = bTx.assemble(signatures);
+
+  // Calculate execution units
+  const exUnits = await calculateTxExUnits(provider, signedTx);
+
+  // Get protocol parameters for percentages
+  const protocolParams = await provider.getProtocolParameters();
+
+  if (protocolParams.maxTxExMem !== MAINNET_PROTOCOL_PARAMETERS.maxTxExMem) {
+    throw new Error('Protocol parameters do not match Mainnet');
+  }
+
+  // Calculate percentages
+  const result = {
+    ...exUnits,
+    memPercentage: (exUnits.mem / Number(protocolParams.maxTxExMem)) * 100,
+    stepsPercentage:
+      (exUnits.steps / Number(protocolParams.maxTxExSteps)) * 100,
+    sizePercentage: (exUnits.txSize / Number(protocolParams.maxTxSize)) * 100,
+  };
+
+  BENCHMARK_RESULTS[name] = result;
+
+  await lucid.awaitTx(await (await signedTx.complete()).submit());
+}

package/tests/utils/index.ts

@@ -1,28 +1,100 @@
+import {
+  negateAssets,
+  noAdaValue,
+} from '@3rd-eye-labs/cardano-offchain-common';
 import {
   addAssets,
   Assets,
+  credentialToAddress,
+  getAddressDetails,
   LucidEvolution,
+  paymentCredentialOf,
   UTxO,
 } from '@lucid-evolution/lucid';
-import { array as A } from 'fp-ts';
-import { negateAssets } from '../../src/utils/value-helpers';
+import { array as A, function as F } from 'fp-ts';
+import { zipWith } from 'fp-ts/lib/Array';
+import { runAndAwaitTxBuilder } from '../test-helpers';
 
+/**
+ * In case passing in address with stake credential, the non stake credential address
+ * is used as well for collecting inputs but cannot increase its value.
+ */
 export async function getValueChangeAtAddressAfterAction<T>(
   lucid: LucidEvolution,
   address: string,
   action: () => Promise<T>,
 ): Promise<[T, Assets]> {
+  const hasStakeCred = getAddressDetails(address).stakeCredential != null;
+
   const valBefore = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
     addAssets(acc, utxo.assets),
   )(await lucid.utxosAt(address));
 
-  const res = await action();
+  const [res, nonStakeCredValChange] = hasStakeCred
+    ? await getValueChangeAtAddressAfterAction(
+        lucid,
+        credentialToAddress(
+          lucid.config().network!,
+          paymentCredentialOf(address),
+        ),
+        action,
+      )
+    : [await action(), {}];
+
+  if (
+    hasStakeCred &&
+    !Object.entries(nonStakeCredValChange).every(([_, amt]) => amt <= 0n)
+  ) {
+    throw new Error("Can't add value to the address without stake credential");
+  }
 
   const valAfter = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
     addAssets(acc, utxo.assets),
   )(await lucid.utxosAt(address));
 
-  return [res, addAssets(valAfter, negateAssets(valBefore))];
+  return [
+    res,
+    addAssets(valAfter, negateAssets(valBefore), nonStakeCredValChange),
+  ];
+}
+
+export async function getValueChangeAtAddressesAfterAction<T>(
+  lucid: LucidEvolution,
+  addresses: string[],
+  action: () => Promise<T>,
+): Promise<[T, Assets[]]> {
+  const valsBefore = [];
+
+  for (const address of addresses) {
+    const utxos = await lucid.utxosAt(address);
+    valsBefore.push(
+      F.pipe(
+        utxos,
+        A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
+      ),
+    );
+  }
+
+  const res = await action();
+
+  const valsAfter = [];
+
+  for (const address of addresses) {
+    const utxos = await lucid.utxosAt(address);
+    valsAfter.push(
+      F.pipe(
+        utxos,
+        A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
+      ),
+    );
+  }
+
+  return [
+    res,
+    zipWith(valsBefore, valsAfter, (valBefore, valAfter) =>
+      addAssets(valAfter, negateAssets(valBefore)),
+    ),
+  ];
 }
 
 export async function getNewUtxosAtAddressAfterAction<T>(
@@ -48,3 +120,49 @@ export async function getNewUtxosAtAddressAfterAction<T>(
     ),
   ];
 }
+
+export async function totalValueAtAddress(
+  lucid: LucidEvolution,
+  addr: string,
+): Promise<Assets> {
+  const utxos = await lucid.utxosAt(addr);
+
+  return F.pipe(
+    utxos,
+    A.reduce<UTxO, Assets>({}, (acc, utxo) => addAssets(acc, utxo.assets)),
+  );
+}
+
+export async function sendValueTo(
+  destinationAddr: string,
+  value: Assets,
+  lucid: LucidEvolution,
+): Promise<void> {
+  await runAndAwaitTxBuilder(
+    lucid,
+    lucid.newTx().pay.ToAddress(destinationAddr, value),
+  );
+}
+
+/**
+ * For all the non-ADA assets in current wallet, create a separate UTXo with each of them.
+ */
+export async function fragmentWallet(lucid: LucidEvolution): Promise<void> {
+  const currentAddr = await lucid.wallet().address();
+
+  const totalVal = await totalValueAtAddress(lucid, currentAddr);
+
+  const otherAssets = Object.keys(noAdaValue(totalVal));
+
+  if (otherAssets.length === 0) return;
+
+  const tx = lucid.newTx();
+
+  for (const asset of otherAssets) {
+    tx.pay.ToAddress(currentAddr, {
+      [asset]: totalVal[asset],
+    });
+  }
+
+  await runAndAwaitTxBuilder(lucid, tx);
+}

package/tsconfig.json

@@ -7,7 +7,15 @@
     "moduleResolution": "nodenext",
     "allowUnreachableCode": true,
     "strict": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "allowUnusedLabels": false,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
   },
   "ts-node": {
     "compilerOptions": {

package/vitest.config.ts

@@ -2,8 +2,10 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    testTimeout: 120000, // 3 minutes
+    hookTimeout: 0,
+    testTimeout: 400_000,
     reporters: 'verbose',
     include: ['./tests/**/*.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    globalSetup: './tests/setup.ts',
   },
 });