@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/tests/stableswap/stableswap.test.ts

@@ -0,0 +1,3891 @@
+import { assert, beforeEach, test } from 'vitest';
+import {
+  IndigoTestContext,
+  repeat,
+  runAndAwaitTx,
+  runAndAwaitTxBuilder,
+} from '../test-helpers';
+import {
+  createIndigoTestContext,
+  EXAMPLE_TOKEN_1,
+} from '../indigo-test-helpers';
+import { benchmarkAndAwaitTx } from '../utils/benchmark-utils';
+import {
+  batchProcessStableswapOrders,
+  cancelStableswapOrder,
+  createStableswapOrder,
+  updateStableswapPoolFees,
+} from '../../src/contracts/stableswap/transactions';
+import {
+  createScriptAddress,
+  fromSystemParamsAsset,
+  mkTreasuryAddr,
+} from '../../src';
+import {
+  addAssets,
+  Assets,
+  credentialToAddress,
+  fromHex,
+  fromText,
+  paymentCredentialOf,
+  UTxO,
+} from '@lucid-evolution/lucid';
+import {
+  findAllNecessaryOrefs,
+  findPriceOracleFromCollateralAsset,
+  findStableswapPool,
+} from '../cdp/cdp-queries';
+import {
+  findSingleStableswapOrder,
+  findStableswapOrders,
+} from './stableswap-queries';
+import { feedPriceOracleTx } from '../../src/contracts/price-oracle/transactions';
+import {
+  addressFromBech32,
+  assetClassValueOf,
+  lovelacesAmt,
+  mkLovelacesOf,
+  negateAssets,
+} from '@3rd-eye-labs/cardano-offchain-common';
+import { runCreateStableswapPool } from './stableswap-actions';
+import { getValueChangeAtAddressAfterAction } from '../utils';
+import { array as A } from 'fp-ts';
+import { runOpenCdp } from '../cdp/actions';
+import { Data } from '@evolution-sdk/evolution';
+import { serialiseStableswapOrderDatum } from '../../src/contracts/stableswap/types-new';
+import { BASE_MAX_EXECUTION_FEE } from '../../src/contracts/stableswap/helpers';
+import { StableswapPoolContent } from '../../src/contracts/cdp/types-new';
+import { mutatedBatchProcessStableswapOrders } from './transactions-mutated';
+import { expectScriptFailure } from '../utils/asserts';
+import {
+  findRandomTreasuryUtxoWithOnlyAda,
+  findRandomTreasuryUtxoWithAsset,
+} from '../queries/treasury-queries';
+import { createUtxoAtTreasury } from '../endpoints/treasury';
+import { rationalFromInt, rationalZero } from '../../src/types/rational';
+
+beforeEach<IndigoTestContext>(async (context: IndigoTestContext) => {
+  await createIndigoTestContext(context);
+});
+
+test<IndigoTestContext>('Stableswap - Create Order', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  await benchmarkAndAwaitTx(
+    'Stableswap - Create Order',
+    await createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+    context.lucid,
+    context.emulator,
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Cancel Order', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await benchmarkAndAwaitTx(
+    'Stableswap - Cancel Order',
+    await cancelStableswapOrder(
+      stableswapOrder.utxo,
+      context.systemParams,
+      context.lucid,
+    ),
+    context.lucid,
+    context.emulator,
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to mint', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      benchmarkAndAwaitTx(
+        'Stableswap - Batch a single order to mint',
+        await batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n - 50_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to mint with no minting fee', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    rationalFromInt(1n),
+    // 0% minting fee.
+    rationalZero,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      await runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 0n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to redeem', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      benchmarkAndAwaitTx(
+        'Stableswap - Batch a single order to redeem',
+        await batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 25_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n - (5_000_000n - 25_000n),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      10_000_000n - 50_000n - 5_000_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + (5_000_000n - 25_000n),
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to redeem with no redemption fee', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    rationalFromInt(1n),
+    // 0% minting fee.
+    rationalZero,
+    // 0% redemption fee.
+    rationalZero,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  // This will not be used in the transaction, but is passed only as a placeholder.
+  treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 0n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n - 5_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n - 5_000_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + 5_000_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to redeem emptying the pool', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const orefs = await findAllNecessaryOrefs(
+    context.lucid,
+    context.systemParams,
+    context.assetConfigs[0].iassetTokenNameAscii,
+    context.assetConfigs[0].collateralAssets[0].collateralAsset,
+  );
+  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
+    context.lucid,
+    orefs.collateralAsset,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    feedPriceOracleTx(
+      context.lucid,
+      priceOracleUtxo!,
+      rationalFromInt(1n),
+      context.assetConfigs[0].collateralAssets[0].oracleParams!,
+      context.emulator.slot,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Mint extra iAsset to have enough to empty the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    runOpenCdp(
+      context,
+      context.systemParams,
+      context.assetConfigs[0].iassetTokenNameAscii,
+      context.assetConfigs[0].collateralAssets[0].collateralAsset,
+      10_000_000n,
+      5_000_000n,
+    ),
+  );
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem all the assets left in the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      // After taking a 0.5% fee, the effective amount is 10_000_000.
+      10_050_251n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_251n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) == 0n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      10_000_000n - 50_000n - 10_050_251n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + 10_000_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to mint assets with smaller scale', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    rationalFromInt(1_000n),
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000n - 50n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to mint assets with bigger scale', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    { numerator: 1n, denominator: 1_000n },
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000_000n - 50_000_000n,
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to redeem assets with smaller scale', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    rationalFromInt(1_000n),
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 25n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n - (5_000_000n - 25_000n),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000n - 50n - 5_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + (5_000_000n - 25_000n),
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch a single order to redeem assets with bigger scale', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    { numerator: 1n, denominator: 1_000n },
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrder.datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          [stableswapOrder.utxo],
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 25_000_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n - (5_000_000n - 25_000n),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      10_000_000_000n - 50_000_000n - 5_000_000_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + (5_000_000n - 25_000n),
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to mint from same owner, 11', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const numberOfOrders = 11;
+
+  await repeat(numberOfOrders, async () => {
+    await runAndAwaitTx(
+      context.lucid,
+      createStableswapOrder(
+        context.assetConfigs[0].iassetTokenNameAscii,
+        EXAMPLE_TOKEN_1,
+        10_000_000n,
+        true,
+        stableswapPool.datum,
+        context.systemParams,
+        context.lucid,
+      ),
+    );
+  });
+
+  const stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      benchmarkAndAwaitTx(
+        'Stableswap - Batch multiple orders to mint from same owner, 11',
+        await batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) ==
+      BigInt(numberOfOrders) * 50_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      BigInt(numberOfOrders) * 10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      BigInt(numberOfOrders) * (10_000_000n - 50_000n),
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to redeem from same owner, 9', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const numberOfOrders = 9;
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      BigInt(numberOfOrders) * 10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await repeat(numberOfOrders, async () => {
+    await runAndAwaitTx(
+      context.lucid,
+      createStableswapOrder(
+        context.assetConfigs[0].iassetTokenNameAscii,
+        EXAMPLE_TOKEN_1,
+        5_000_000n,
+        false,
+        stableswapPool.datum,
+        context.systemParams,
+        context.lucid,
+      ),
+    );
+  });
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      benchmarkAndAwaitTx(
+        'Stableswap - Batch multiple orders to redeem from same owner, 9',
+        await batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+        context.lucid,
+        context.emulator,
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) ==
+      BigInt(numberOfOrders) * 25_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      BigInt(numberOfOrders) * (10_000_000n - (5_000_000n - 25_000n)),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      BigInt(numberOfOrders) * (10_000_000n - 50_000n - 5_000_000n) &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        BigInt(numberOfOrders) * (-10_000_000n + (5_000_000n - 25_000n)),
+    'Unexpected value received by order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to mint from different owners', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n + 25_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n + 5_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 10_000_000n - 50_000n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == -10_000_000n,
+    'Unexpected value received by order #1 owner',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 5_000_000n - 25_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == -5_000_000n,
+    'Unexpected value received by order #2 owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to mint with rounded amounts', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    // 0.999991 relative price
+    { numerator: 1_000_000n, denominator: 1_000_009n },
+    //15% fee
+    { numerator: 15n, denominator: 100n },
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const numberOfOrders = 10;
+
+  await repeat(numberOfOrders, async () => {
+    await runAndAwaitTx(
+      context.lucid,
+      createStableswapOrder(
+        context.assetConfigs[0].iassetTokenNameAscii,
+        EXAMPLE_TOKEN_1,
+        // The eq. iAsset amount is 100,000.9, rounded to 100,000.
+        100_000n,
+        true,
+        stableswapPool.datum,
+        context.systemParams,
+        context.lucid,
+      ),
+    );
+  });
+
+  const stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) ==
+      BigInt(numberOfOrders) * 15_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      BigInt(numberOfOrders) * 100_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      BigInt(numberOfOrders) * (100_000n - 15_000n) &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        BigInt(numberOfOrders) * -100_000n,
+    'Unexpected value received by orders owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 0n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == 0n,
+    'Unexpected value received by the admin',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch orders to mint with insignificant value', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    // The collateral asset has one more decimal place than the iAsset.
+    rationalFromInt(10n),
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      // 1.0000001 of collateral asset, equivalent to 1 iAsset.
+      10_000_001n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 5_000n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      10_000_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 1_000_000n - 5_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == -10_000_001n,
+    'Unexpected value received by orders owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 0n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == 1n,
+    'Unexpected value received by the admin',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to redeem from different owners', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Mint iAsset to supply the pool with collateral asset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      5_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      2_500_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const numberOfOrders = 2;
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 25_000n + 12_500n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      BigInt(numberOfOrders) * 10_000_000n -
+        (5_000_000n - 25_000n) -
+        (2_500_000n - 12_500n),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) ==
+      10_000_000n - 50_000n - 5_000_000n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + (5_000_000n - 25_000n),
+    'Unexpected value received by order #1 owner',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      10_000_000n - 50_000n - 2_500_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        -10_000_000n + (2_500_000n - 12_500n),
+    'Unexpected value received by order #2 owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch multiple orders to redeem with rounded amounts', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    // 1.000019 relative price
+    { numerator: 1_000_000n, denominator: 999_981n },
+    // 1% fee
+    { numerator: 1n, denominator: 100n },
+    // 0.0015% fee
+    { numerator: 15n, denominator: 1_000_000n },
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const numberOfOrders = 3;
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      BigInt(numberOfOrders) * 200_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await repeat(numberOfOrders, async () => {
+    await runAndAwaitTx(
+      context.lucid,
+      createStableswapOrder(
+        context.assetConfigs[0].iassetTokenNameAscii,
+        EXAMPLE_TOKEN_1,
+        // The fee will be 1.5 iAssets, rounded to 1.
+        // The equivalent collateral amt after fees is 100000.9000171, rounded to 100,000.
+        100_000n,
+        false,
+        stableswapPool.datum,
+        context.systemParams,
+        context.lucid,
+      ),
+    );
+  });
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      await runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) ==
+      BigInt(numberOfOrders) * 1n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      BigInt(numberOfOrders) * (200_000n - 100_000n),
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) ==
+      BigInt(numberOfOrders) * -100_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) ==
+        BigInt(numberOfOrders) * 100_000n,
+    'Unexpected value received by order owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 0n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == 0n,
+    'Unexpected value received by the admin',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch an order to redeem with insignificant value', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+    // The iAsset has one more decimal place than the collateral asset.
+    { numerator: 1n, denominator: 10n },
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      2_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      // 1.000001 of iAsset, equivalent to 1 collateral asset.
+      10_000_001n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      await runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      2_000_000n - 1_000_000n + 5_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == -10_000_001n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == 1_000_000n - 5_000n,
+    'Unexpected value received by order owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 1n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == 0n,
+    'Unexpected value received by the admin',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch an order to mint with an order to redeem', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      20_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  // Order to redeem.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Order to mint.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n + 50_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  // The first 20_000_000 come from the minting order processed before the batch.
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      20_000_000n + 50_000n,
+    'Unexpected collateral asset value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n - 50_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == -10_000_000n,
+    'Unexpected value received by minting order owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == -10_000_000n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) ==
+        10_000_000n - 50_000n,
+    'Unexpected value received by redeeming order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch an order to mint with an order to redeem (with destination datum)', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  // Mint iAsset to supply the pool with collateral asset.
+  // It also provides the treasury with a UTxO with iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      20_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      undefined,
+      Data.fromCBORHex('d87980'),
+    ),
+  );
+
+  let stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      stableswapOrders.map((order) => order.utxo),
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  // Order to redeem.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      undefined,
+      Data.fromCBORHex('d87980'),
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Order to mint.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      undefined,
+      Data.fromCBORHex('d87a80'),
+    ),
+  );
+
+  stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithAsset(
+    context.lucid,
+    context.systemParams,
+    iassetAc,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n + 50_000n &&
+      0n <= lovelacesAmt(treasuryValChange) &&
+      lovelacesAmt(treasuryValChange) <= 9_000n,
+    'Unexpected value received by the treasury',
+  );
+
+  // This comes from the minting order processed before the batch.
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) ==
+      20_000_000n + 50_000n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == 10_000_000n - 50_000n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == -10_000_000n,
+    'Unexpected value received by minting order owner',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == -10_000_000n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) ==
+        10_000_000n - 50_000n,
+    'Unexpected value received by redeeming order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batch an order to mint with an order to redeem with an empty pool', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  let orefs = await findAllNecessaryOrefs(
+    context.lucid,
+    context.systemParams,
+    context.assetConfigs[0].iassetTokenNameAscii,
+    context.assetConfigs[0].collateralAssets[0].collateralAsset,
+  );
+  const priceOracleUtxo = await findPriceOracleFromCollateralAsset(
+    context.lucid,
+    orefs.collateralAsset,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    feedPriceOracleTx(
+      context.lucid,
+      priceOracleUtxo!,
+      rationalFromInt(1n),
+      context.assetConfigs[0].collateralAssets[0].oracleParams!,
+      context.emulator.slot,
+    ),
+  );
+
+  const initialAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  // Order to mint.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  orefs = await findAllNecessaryOrefs(
+    context.lucid,
+    context.systemParams,
+    context.assetConfigs[0].iassetTokenNameAscii,
+    context.assetConfigs[0].collateralAssets[0].collateralAsset,
+  );
+
+  // Get some iAsset to be able to redeem from stableswap pool.
+  await runAndAwaitTx(
+    context.lucid,
+    runOpenCdp(
+      context,
+      context.systemParams,
+      context.assetConfigs[0].iassetTokenNameAscii,
+      context.assetConfigs[0].collateralAssets[0].collateralAsset,
+      50_000_000n,
+      20_000_000n,
+    ),
+  );
+
+  const initialUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  // Order to redeem.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_050_251n,
+      false,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  const stableswapOrders = await findStableswapOrders(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  const [__, treasuryValChange] = await getValueChangeAtAddressAfterAction(
+    context.lucid,
+    mkTreasuryAddr(context.lucid, context.systemParams),
+    async () =>
+      runAndAwaitTx(
+        context.lucid,
+        batchProcessStableswapOrders(
+          stableswapOrders.map((order) => order.utxo),
+          stableswapPool.utxo,
+          treasuryUtxo,
+          context.systemParams,
+          context.lucid,
+        ),
+      ),
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  const finalAdminValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.admin.address));
+
+  const finalUserValue = A.reduce<UTxO, Assets>({}, (acc, utxo) =>
+    addAssets(acc, utxo.assets),
+  )(await context.lucid.utxosAt(context.users.user.address));
+
+  const adminValueDiff = addAssets(
+    finalAdminValue,
+    negateAssets(initialAdminValue),
+  );
+
+  const userValueDiff = addAssets(
+    finalUserValue,
+    negateAssets(initialUserValue),
+  );
+
+  const iassetAc = {
+    currencySymbol: fromHex(
+      context.systemParams.stableswapParams.iassetSymbol.unCurrencySymbol,
+    ),
+    tokenName: stableswapOrders[0].datum.iasset,
+  };
+
+  assert(
+    assetClassValueOf(treasuryValChange, iassetAc) == 50_000n + 50_251n,
+    'Unexpected iAsset value received by the treasury',
+  );
+
+  assert(
+    assetClassValueOf(stableswapPool.utxo.assets, EXAMPLE_TOKEN_1) == 0n,
+    'Unexpected value held by stableswap pool',
+  );
+
+  assert(
+    assetClassValueOf(adminValueDiff, iassetAc) == 10_000_000n - 50_000n &&
+      assetClassValueOf(adminValueDiff, EXAMPLE_TOKEN_1) == -10_000_000n,
+    'Unexpected value received by minting order owner',
+  );
+
+  assert(
+    assetClassValueOf(userValueDiff, iassetAc) == -10_050_251n &&
+      assetClassValueOf(userValueDiff, EXAMPLE_TOKEN_1) == 10_000_000n,
+    'Unexpected value received by redeeming order owner',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Update fees from fee manager', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool: { utxo: UTxO; datum: StableswapPoolContent } =
+    await findStableswapPool(
+      context.lucid,
+      context.systemParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+      fromText(context.assetConfigs[0].iassetTokenNameAscii),
+      EXAMPLE_TOKEN_1,
+    );
+
+  const feeTxHash = await runAndAwaitTxBuilder(
+    context.lucid,
+    context.lucid.newTx().pay.ToAddress(
+      credentialToAddress(context.lucid.config().network!, {
+        hash: context.systemParams.validatorHashes.stableswapHash,
+        type: 'Script',
+      }),
+      mkLovelacesOf(2_000_000n),
+    ),
+  );
+
+  assert(
+    stableswapPool.datum.mintingFeeRatio.numerator === 5n &&
+      stableswapPool.datum.mintingFeeRatio.denominator === 1_000n,
+    'Unexpected minting fee percentage prior to update',
+  );
+
+  assert(
+    stableswapPool.datum.redemptionFeeRatio.numerator === 5n &&
+      stableswapPool.datum.redemptionFeeRatio.denominator === 1_000n,
+    'Unexpected redemption fee percentage prior to update',
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await benchmarkAndAwaitTx(
+    'Stableswap - Update fees',
+    await updateStableswapPoolFees(
+      stableswapPool.utxo,
+      { txHash: feeTxHash, outputIndex: 0 },
+      { numerator: 1n, denominator: 100n },
+      { numerator: 1n, denominator: 100n },
+      context.systemParams,
+      context.lucid,
+    ),
+    context.lucid,
+    context.emulator,
+  );
+
+  ///////////////////////////////////
+  // Checks after last transaction //
+  ///////////////////////////////////
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  assert(
+    stableswapPool.datum.mintingFeeRatio.numerator === 1n &&
+      stableswapPool.datum.mintingFeeRatio.denominator === 100n,
+    'Unexpected minting fee percentage',
+  );
+
+  assert(
+    stableswapPool.datum.mintingFeeRatio.numerator === 1n &&
+      stableswapPool.datum.mintingFeeRatio.denominator === 100n,
+    'Unexpected redemption fee percentage',
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Update fees from fee manager - fails with large minting fee', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool: { utxo: UTxO; datum: StableswapPoolContent } =
+    await findStableswapPool(
+      context.lucid,
+      context.systemParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+      fromText(context.assetConfigs[0].iassetTokenNameAscii),
+      EXAMPLE_TOKEN_1,
+    );
+
+  const feeTxHash = await runAndAwaitTxBuilder(
+    context.lucid,
+    context.lucid.newTx().pay.ToAddress(
+      credentialToAddress(context.lucid.config().network!, {
+        hash: context.systemParams.validatorHashes.stableswapHash,
+        type: 'Script',
+      }),
+      mkLovelacesOf(2_000_000n),
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await expectScriptFailure(
+    'Minting fee ratio is between [0%, 100%]',
+    updateStableswapPoolFees(
+      stableswapPool.utxo,
+      { txHash: feeTxHash, outputIndex: 0 },
+      { numerator: 1_005n, denominator: 10n },
+      { numerator: 1n, denominator: 100n },
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Update fees from fee manager - fails with large redemption fee', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool: { utxo: UTxO; datum: StableswapPoolContent } =
+    await findStableswapPool(
+      context.lucid,
+      context.systemParams.validatorHashes.cdpHash,
+      fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+      fromText(context.assetConfigs[0].iassetTokenNameAscii),
+      EXAMPLE_TOKEN_1,
+    );
+
+  const feeTxHash = await runAndAwaitTxBuilder(
+    context.lucid,
+    context.lucid.newTx().pay.ToAddress(
+      credentialToAddress(context.lucid.config().network!, {
+        hash: context.systemParams.validatorHashes.stableswapHash,
+        type: 'Script',
+      }),
+      mkLovelacesOf(2_000_000n),
+    ),
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await expectScriptFailure(
+    'Redemption fee ratio is between [0%, 100%]',
+    updateStableswapPoolFees(
+      stableswapPool.utxo,
+      { txHash: feeTxHash, outputIndex: 0 },
+      { numerator: 1n, denominator: 100n },
+      { numerator: 1_005n, denominator: 10n },
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Process a two-step order, ex. USDC -> iUSD -> USDC', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  let stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+  const userAddress = await context.lucid.wallet().address();
+  const pkh = paymentCredentialOf(userAddress);
+
+  // Create order to mint iAsset, forwarding to a stableswap order to redeem the iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      createScriptAddress(
+        context.lucid.config().network!,
+        context.systemParams.validatorHashes.stableswapHash,
+      ),
+      Data.fromCBORHex(
+        serialiseStableswapOrderDatum({
+          iasset: fromHex(
+            fromText(context.assetConfigs[0].iassetTokenNameAscii),
+          ),
+          collateralAsset: EXAMPLE_TOKEN_1,
+          owner: fromHex(pkh.hash),
+          destination: addressFromBech32(userAddress),
+          destinationInlineDatum: null,
+          maxExecutionFee: BASE_MAX_EXECUTION_FEE,
+          maxFeeRatio: stableswapPool.datum.mintingFeeRatio,
+        }),
+      ),
+      BASE_MAX_EXECUTION_FEE,
+      1_000_000n,
+    ),
+  );
+
+  let stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  let treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+
+  // Redeem part of the collateral asset previously supplied to the pool.
+  stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await runAndAwaitTx(
+    context.lucid,
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Batcher tries to steal more than the max execution fee', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Create order to mint iAsset.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      undefined,
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      10_000_000n,
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await expectScriptFailure(
+    'Minted amount wrongly sent to order destination',
+    mutatedBatchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+      {
+        type: 'exceed-max-execution-fee',
+        maxExecutionFee: BASE_MAX_EXECUTION_FEE + 1_000_000n,
+      },
+    ),
+  );
+});
+
+test<IndigoTestContext>('Stableswap - Pool exceeds max fee percentage', async (context: IndigoTestContext) => {
+  context.lucid.selectWallet.fromSeed(context.users.admin.seedPhrase);
+
+  await runCreateStableswapPool(
+    context.assetConfigs[0].iassetTokenNameAscii,
+    EXAMPLE_TOKEN_1,
+    context,
+  );
+
+  const stableswapPool = await findStableswapPool(
+    context.lucid,
+    context.systemParams.validatorHashes.cdpHash,
+    fromSystemParamsAsset(context.systemParams.stableswapParams.cdpToken),
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  context.lucid.selectWallet.fromSeed(context.users.user.seedPhrase);
+
+  // Create order to mint iAsset, though with a 0% max fee percentage.
+  await runAndAwaitTx(
+    context.lucid,
+    createStableswapOrder(
+      context.assetConfigs[0].iassetTokenNameAscii,
+      EXAMPLE_TOKEN_1,
+      10_000_000n,
+      true,
+      stableswapPool.datum,
+      context.systemParams,
+      context.lucid,
+      undefined,
+      undefined,
+      BASE_MAX_EXECUTION_FEE,
+      0n,
+      rationalFromInt(0n),
+    ),
+  );
+
+  const stableswapOrder = await findSingleStableswapOrder(
+    context.lucid,
+    context.systemParams.validatorHashes.stableswapHash,
+    fromText(context.assetConfigs[0].iassetTokenNameAscii),
+    EXAMPLE_TOKEN_1,
+  );
+
+  await createUtxoAtTreasury(
+    mkLovelacesOf(2_000_000n),
+    context.systemParams,
+    context,
+  );
+
+  const treasuryUtxo = await findRandomTreasuryUtxoWithOnlyAda(
+    context.lucid,
+    context.systemParams,
+  );
+
+  await expectScriptFailure(
+    'Pool minting fee exceeds order max fee ratio',
+    batchProcessStableswapOrders(
+      [stableswapOrder.utxo],
+      stableswapPool.utxo,
+      treasuryUtxo,
+      context.systemParams,
+      context.lucid,
+    ),
+  );
+});