@indigo-labs/indigo-sdk 0.5.4 → 0.5.6

package/tests/stableswap/transactions-mutated.ts

@@ -1,348 +0,0 @@
-import {
-  addAssets,
-  Data,
-  fromHex,
-  LucidEvolution,
-  OutRef,
-  sortUTxOs,
-  toHex,
-  TxBuilder,
-  UTxO,
-} from '@lucid-evolution/lucid';
-import {
-  parseStableswapOrderDatumOrThrow,
-  serialiseStableswapOrderRedeemer,
-  StableswapOrderDatum,
-} from '../../src/contracts/stableswap/types-new';
-import {
-  fromSystemParamsScriptRef,
-  SystemParams,
-  treasuryFeeTx,
-} from '../../src';
-import {
-  addressToBech32,
-  assetClassToUnit,
-  getInlineDatumOrThrow,
-  lovelacesAmt,
-  matchSingle,
-  mkAssetsOf,
-  mkLovelacesOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-import { isEmpty } from 'fp-ts/lib/Array';
-import { array as A, function as F } from 'fp-ts';
-import { calculateFeeFromRatio } from '../../src/utils/indigo-helpers';
-import {
-  parseStableswapPoolDatumOrThrow,
-  serialiseCdpRedeemer,
-  serialiseStableswapPoolDatum,
-} from '../../src/contracts/cdp/types-new';
-import { createDestinationDatum } from '../../src/contracts/stableswap/helpers';
-import {
-  rationalDiv,
-  rationalFloor,
-  rationalFromInt,
-  rationalMul,
-} from '../../src/types/rational';
-
-type StableswapOrderInfo = {
-  utxo: UTxO;
-  datum: StableswapOrderDatum;
-  suppliedIasset: bigint;
-  suppliedCollateralAsset: bigint;
-};
-export type MutatedBatchProcessStableswapOrdersType = {
-  type: 'exceed-max-execution-fee';
-  maxExecutionFee: bigint;
-};
-export async function mutatedBatchProcessStableswapOrders(
-  stableswapOrderOrefs: OutRef[],
-  stableswapPoolOref: OutRef,
-  treasuryOref: OutRef,
-  sysParams: SystemParams,
-  lucid: LucidEvolution,
-  type: MutatedBatchProcessStableswapOrdersType,
-): Promise<TxBuilder> {
-  const stableswapScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.stableswapValidatorRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single Stableswap Ref Script UTXO'),
-  );
-
-  const cdpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef),
-    ]),
-    (_) => new Error('Expected a single CDP Ref Script UTXO'),
-  );
-
-  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.iAssetTokenPolicyRef,
-      ),
-    ]),
-    (_) => new Error('Expected a single iasset token policy Ref Script UTXO'),
-  );
-
-  if (isEmpty(stableswapOrderOrefs)) {
-    throw new Error('At least one order must be provided.');
-  }
-
-  const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
-
-  const sortedStableswapOrderUtxos = sortUTxOs(
-    stableswapOrderUtxos,
-    'Canonical',
-  );
-
-  if (sortedStableswapOrderUtxos.length !== stableswapOrderOrefs.length) {
-    throw new Error('Expected certain number of orders');
-  }
-
-  const mainOrderUtxo = sortedStableswapOrderUtxos[0];
-
-  const mainOrderDatum = parseStableswapOrderDatumOrThrow(
-    getInlineDatumOrThrow(mainOrderUtxo),
-  );
-
-  const iassetAc = {
-    currencySymbol: fromHex(
-      sysParams.stableswapParams.iassetSymbol.unCurrencySymbol,
-    ),
-    tokenName: mainOrderDatum.iasset,
-  };
-
-  const collateralAc = mainOrderDatum.collateralAsset;
-
-  const ordersInfo: StableswapOrderInfo[] = sortedStableswapOrderUtxos.map(
-    (orderUtxo) => {
-      const orderDatum = parseStableswapOrderDatumOrThrow(
-        getInlineDatumOrThrow(orderUtxo),
-      );
-
-      if (
-        toHex(orderDatum.iasset) != toHex(mainOrderDatum.iasset) ||
-        toHex(orderDatum.collateralAsset.currencySymbol) !=
-          toHex(mainOrderDatum.collateralAsset.currencySymbol) ||
-        toHex(orderDatum.collateralAsset.tokenName) !=
-          toHex(mainOrderDatum.collateralAsset.tokenName)
-      ) {
-        throw new Error('Wrong batch of orders');
-      }
-
-      const suppliedIasset = orderUtxo.assets[assetClassToUnit(iassetAc)] ?? 0n;
-      const suppliedCollateralAsset =
-        orderUtxo.assets[assetClassToUnit(collateralAc)] ?? 0n;
-
-      if (
-        (suppliedIasset != 0n && suppliedCollateralAsset != 0n) ||
-        (suppliedIasset == 0n && suppliedCollateralAsset == 0n)
-      ) {
-        throw new Error(
-          'An order must supply either iAsset or collateral asset',
-        );
-      }
-
-      return {
-        utxo: orderUtxo,
-        datum: orderDatum,
-        suppliedIasset: suppliedIasset,
-        suppliedCollateralAsset: suppliedCollateralAsset,
-      };
-    },
-  );
-
-  const totalSuppliedAssets = F.pipe(
-    ordersInfo,
-    A.reduce<StableswapOrderInfo, [bigint, bigint]>(
-      [0n, 0n],
-      (acc, orderInfo) => [
-        acc[0] + orderInfo.suppliedIasset,
-        acc[1] + orderInfo.suppliedCollateralAsset,
-      ],
-    ),
-  );
-
-  const totalSuppliedIasset = totalSuppliedAssets[0];
-
-  const totalSuppliedCollateralAsset = totalSuppliedAssets[1];
-
-  const stableswapPoolUtxo = matchSingle(
-    await lucid.utxosByOutRef([stableswapPoolOref]),
-    (_) => new Error('Expected a single cdp UTXO'),
-  );
-
-  const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
-    getInlineDatumOrThrow(stableswapPoolUtxo),
-  );
-
-  const redemptionFee = calculateFeeFromRatio(
-    stableswapPoolDatum.redemptionFeeRatio,
-    totalSuppliedIasset,
-  );
-
-  const totalEffectiveSuppliedIasset = totalSuppliedIasset - redemptionFee;
-
-  const collateralAmtChangePool =
-    totalSuppliedCollateralAsset -
-    rationalFloor(
-      rationalMul(
-        rationalFromInt(totalEffectiveSuppliedIasset),
-        stableswapPoolDatum.collateralToIassetRatio,
-      ),
-    );
-
-  const amountToMint =
-    rationalFloor(
-      rationalDiv(
-        rationalFromInt(totalSuppliedCollateralAsset),
-        stableswapPoolDatum.collateralToIassetRatio,
-      ),
-    ) - totalEffectiveSuppliedIasset;
-
-  const mintingFee = calculateFeeFromRatio(
-    stableswapPoolDatum.mintingFeeRatio,
-    amountToMint,
-  );
-
-  const tx = lucid
-    .newTx()
-    .readFrom([
-      stableswapScriptRefUtxo,
-      cdpScriptRefUtxo,
-      iAssetTokenPolicyRefScriptUtxo,
-    ])
-    .collectFrom([stableswapPoolUtxo], {
-      kind: 'selected',
-      makeRedeemer: (inputIndices) =>
-        serialiseCdpRedeemer({
-          Stableswap: {
-            forwardingInputIndex: inputIndices[0],
-          },
-        }),
-      inputs: [mainOrderUtxo],
-    })
-    .pay.ToContract(
-      stableswapPoolUtxo.address,
-      {
-        kind: 'inline',
-        value: serialiseStableswapPoolDatum(stableswapPoolDatum),
-      },
-      collateralAmtChangePool != 0n
-        ? addAssets(
-            stableswapPoolUtxo.assets,
-            mkAssetsOf(collateralAc, collateralAmtChangePool),
-          )
-        : stableswapPoolUtxo.assets,
-    );
-
-  const fee = mintingFee + redemptionFee;
-
-  if (fee > 0) {
-    await treasuryFeeTx(
-      iassetAc,
-      fee,
-      0n,
-      lucid,
-      sysParams,
-      tx,
-      stableswapPoolOref,
-      treasuryOref,
-    );
-  }
-
-  if (amountToMint != 0n) {
-    tx.mintAssets(mkAssetsOf(iassetAc, amountToMint), Data.void());
-  }
-
-  F.pipe(
-    ordersInfo,
-    A.reduce<StableswapOrderInfo, TxBuilder>(tx, (acc, orderInfo) => {
-      const iassetSupplied =
-        orderInfo.utxo.assets[assetClassToUnit(iassetAc)] ?? 0n;
-
-      const collateralAssetSupplied =
-        orderInfo.utxo.assets[assetClassToUnit(collateralAc)] ?? 0n;
-
-      const isMinting = iassetSupplied > 0n ? false : true;
-
-      const iAssetEquivalentSupplied = isMinting
-        ? rationalFloor(
-            rationalDiv(
-              rationalFromInt(collateralAssetSupplied),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          )
-        : iassetSupplied;
-
-      const effectiveiAssetEquivalentSupplied = isMinting
-        ? iAssetEquivalentSupplied -
-          calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            iAssetEquivalentSupplied,
-          )
-        : iAssetEquivalentSupplied -
-          calculateFeeFromRatio(
-            stableswapPoolDatum.redemptionFeeRatio,
-            iAssetEquivalentSupplied,
-          );
-
-      const amountToReceive = isMinting
-        ? effectiveiAssetEquivalentSupplied
-        : rationalFloor(
-            rationalMul(
-              rationalFromInt(effectiveiAssetEquivalentSupplied),
-              stableswapPoolDatum.collateralToIassetRatio,
-            ),
-          );
-
-      const maxExecutionFee =
-        type.type === 'exceed-max-execution-fee'
-          ? type.maxExecutionFee
-          : orderInfo.datum.maxExecutionFee;
-
-      return acc
-        .collectFrom(
-          [orderInfo.utxo],
-          orderInfo.utxo == mainOrderUtxo
-            ? serialiseStableswapOrderRedeemer('BatchProcessStableswapOrders')
-            : {
-                kind: 'selected',
-                makeRedeemer: (inputIndices: bigint[]) => {
-                  return serialiseStableswapOrderRedeemer({
-                    BatchAuxiliary: {
-                      ownInputIndex: inputIndices[0],
-                      mainOrderInputIndex: inputIndices[1],
-                    },
-                  });
-                },
-                inputs: [orderInfo.utxo, mainOrderUtxo],
-              },
-        )
-        .pay.ToAddressWithData(
-          addressToBech32(orderInfo.datum.destination, lucid.config().network!),
-          {
-            kind: 'inline',
-            value: createDestinationDatum(
-              orderInfo.datum.destinationInlineDatum ?? null,
-              orderInfo.utxo,
-            ),
-          },
-          addAssets(
-            // Currently, we always take the max execution fee from the order utxo.
-            // This can be improved so that we take the actual execution fee.
-            mkLovelacesOf(
-              lovelacesAmt(orderInfo.utxo.assets) - maxExecutionFee,
-            ),
-            isMinting
-              ? mkAssetsOf(iassetAc, amountToReceive)
-              : mkAssetsOf(collateralAc, amountToReceive),
-          ),
-        );
-    }),
-  );
-  return tx;
-}

package/tests/staking.test.ts

@@ -1,172 +0,0 @@
-import { beforeEach, expect, test } from 'vitest';
-import { IndigoTestContext, runAndAwaitTx } from './test-helpers';
-import { addrDetails } from '../src/utils/lucid-utils';
-import { findStakingPosition } from './queries/staking-queries';
-import {
-  adjustStakingPosition,
-  closeStakingPosition,
-  distributeAda,
-  openStakingPosition,
-} from '../src/contracts/staking/transactions';
-import {
-  collectorFeeTx,
-  findStakingManager,
-  fromSystemParamsAsset,
-} from '../src';
-import { createIndigoTestContext } from './indigo-test-helpers';
-import { benchmarkAndAwaitTx } from './utils/benchmark-utils';
-import {
-  findAllCollectors,
-  findRandomCollector,
-} from './queries/collector-queries';
-import { getValueChangeAtAddressAfterAction, sendValueTo } from './utils';
-import {
-  lovelacesAmt,
-  mkAssetsOf,
-} from '@3rd-eye-labs/cardano-offchain-common';
-
-beforeEach<IndigoTestContext>(async (context: IndigoTestContext) => {
-  await createIndigoTestContext(context);
-});
-
-test<IndigoTestContext>('Staking - Create Position', async ({
-  lucid,
-  emulator,
-  systemParams,
-}: IndigoTestContext) => {
-  await benchmarkAndAwaitTx(
-    'Staking - Create Position',
-    await openStakingPosition(1_000_000n, systemParams, lucid),
-    lucid,
-    emulator,
-  );
-});
-
-test<IndigoTestContext>('Staking - Adjust Position', async ({
-  lucid,
-  emulator,
-  systemParams,
-}: IndigoTestContext) => {
-  await runAndAwaitTx(
-    lucid,
-    openStakingPosition(1_000_000n, systemParams, lucid),
-  );
-
-  const [pkh, __] = await addrDetails(lucid);
-  const myStakingPosition = await findStakingPosition(
-    lucid,
-    systemParams.validatorHashes.stakingHash,
-    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
-    pkh.hash,
-  );
-
-  await benchmarkAndAwaitTx(
-    'Staking - Adjust Position',
-    await adjustStakingPosition(
-      myStakingPosition.utxo,
-      1_000_000n,
-      systemParams,
-      lucid,
-    ),
-    lucid,
-    emulator,
-  );
-});
-
-// TODO: fails with the Lucid Evolution error: `Error: Not enough ADA leftover to include non-ADA assets in a change address`
-test.todo<IndigoTestContext>(
-  'Staking - Close Position',
-  async ({ lucid, emulator, systemParams, users }: IndigoTestContext) => {
-    lucid.selectWallet.fromSeed(users.admin.seedPhrase);
-
-    await sendValueTo(
-      users.user2.address,
-      mkAssetsOf(
-        fromSystemParamsAsset(systemParams.govParams.indyAsset),
-        1_000_000n,
-      ),
-      lucid,
-    );
-
-    lucid.selectWallet.fromSeed(users.user2.seedPhrase);
-
-    await runAndAwaitTx(
-      lucid,
-      openStakingPosition(1_000_000n, systemParams, lucid),
-    );
-
-    const [pkh, __] = await addrDetails(lucid);
-    const myStakingPosition = await findStakingPosition(
-      lucid,
-      systemParams.validatorHashes.stakingHash,
-      fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
-      pkh.hash,
-    );
-
-    await benchmarkAndAwaitTx(
-      'Staking - Close Position',
-      await closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
-      lucid,
-      emulator,
-    );
-  },
-);
-
-test<IndigoTestContext>('Staking - Distribute ADA to Stakers', async ({
-  lucid,
-  users,
-  emulator,
-  systemParams,
-}: IndigoTestContext) => {
-  await runAndAwaitTx(
-    lucid,
-    openStakingPosition(1_000_000n, systemParams, lucid),
-  );
-
-  const collectorOref = await findRandomCollector(
-    lucid,
-    systemParams.validatorHashes.collectorHash,
-  );
-  const tx = lucid.newTx();
-  await collectorFeeTx(100_000_000n, lucid, systemParams, tx, collectorOref);
-  await runAndAwaitTx(lucid, Promise.resolve(tx));
-
-  const collectorUtxo = (
-    await findAllCollectors(lucid, systemParams.validatorHashes.collectorHash)
-  ).find((utxo) => utxo.assets['lovelace'] > 100_000_000n);
-  if (!collectorUtxo) {
-    throw new Error('Expected a collector UTXO');
-  }
-
-  await benchmarkAndAwaitTx(
-    'Staking - Distribute ADA to Stakers',
-    await distributeAda(
-      (await findStakingManager(systemParams, lucid)).utxo,
-      [collectorUtxo],
-      systemParams,
-      lucid,
-    ),
-    lucid,
-    emulator,
-  );
-
-  const [pkh, __] = await addrDetails(lucid);
-  const myStakingPosition = await findStakingPosition(
-    lucid,
-    systemParams.validatorHashes.stakingHash,
-    fromSystemParamsAsset(systemParams.stakingParams.stakingToken),
-    pkh.hash,
-  );
-
-  const [____, userValChange] = await getValueChangeAtAddressAfterAction(
-    lucid,
-    users.admin.address,
-    () =>
-      runAndAwaitTx(
-        lucid,
-        closeStakingPosition(myStakingPosition.utxo, systemParams, lucid),
-      ),
-  );
-
-  expect(lovelacesAmt(userValChange)).toBeGreaterThan(95_000_000n); // There is some loss due to tx fees.
-});

package/tests/test-helpers.ts

@@ -1,94 +0,0 @@
-import {
-  Emulator,
-  EmulatorAccount,
-  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';
-
-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 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;
-}
-
-export async function runAndAwaitTxBuilder(
-  lucid: LucidEvolution,
-  transaction: TxBuilder,
-  extraSigners: string[] = [],
-): Promise<string> {
-  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;
-}
-
-export async function repeat(
-  times: number,
-  action: (isLast: boolean, idx: number) => Promise<void>,
-): Promise<void> {
-  for (let i = 0; i < times; i++) {
-    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/actions.ts

@@ -1,67 +0,0 @@
-import { Assets, TxBuilder } from '@lucid-evolution/lucid';
-import { LucidContext } from '../test-helpers';
-import { createUtxoAtTreasury } from '../endpoints/treasury';
-import { SystemParams, treasuryMerge, treasurySplit } from '../../src';
-import { findAllTreasuryUtxos } from '../../src/contracts/treasury/queries';
-import { assert } from 'vitest';
-
-export async function treasuryMergeTx(
-  context: LucidContext,
-  sysParams: SystemParams,
-  treasuryOutputs: Assets[],
-): Promise<TxBuilder> {
-  for (const output of treasuryOutputs) {
-    await createUtxoAtTreasury(output, sysParams, context);
-  }
-
-  const treasuryUtxos = await findAllTreasuryUtxos(context.lucid, sysParams);
-
-  // 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, sysParams);
-}
-
-export async function treasurySplitTx(
-  context: LucidContext,
-  sysParams: SystemParams,
-  treasuryOutput: Assets,
-): Promise<TxBuilder> {
-  await createUtxoAtTreasury(treasuryOutput, sysParams, context);
-
-  const treasuryUtxos = await findAllTreasuryUtxos(context.lucid, sysParams);
-
-  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, sysParams);
-}