@indigo-labs/indigo-sdk 0.5.0 → 0.5.2

package/dist/index.mjs

@@ -11250,7 +11250,11 @@ async function findCollateralAsset(lucid, sysParams, iassetName, collateralAsset
 }
 
 // src/contracts/stableswap/helpers.ts
-import { fromHex as fromHex19, fromText as fromText14 } from "@lucid-evolution/lucid";
+import {
+  fromHex as fromHex19,
+  fromText as fromText14,
+  toHex as toHex19
+} from "@lucid-evolution/lucid";
 import { array as A16, ord as Ord5, function as F27 } from "fp-ts";
 
 // src/contracts/stableswap/types-new.ts
@@ -11355,10 +11359,15 @@ function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
 
 // src/contracts/stableswap/helpers.ts
 import { Data as Data52 } from "@evolution-sdk/evolution";
-import { assetClassValueOf as assetClassValueOf12 } from "@3rd-eye-labs/cardano-offchain-common";
+import {
+  addressToBech32 as addressToBech323,
+  assetClassValueOf as assetClassValueOf12,
+  lovelacesAmt as lovelacesAmt5
+} from "@3rd-eye-labs/cardano-offchain-common";
 var BASE_MAX_EXECUTION_FEE = 1620000n;
-var defaultOrderProcessingConfig = {
-  ignoreMaxExecutionFeeConstraint: false
+var defaultPSMProcessingConfig = {
+  enforceMaxExecutionFeeConstraint: true,
+  enforceMinLovelaceConstraint: true
 };
 function createDestinationDatum(datum, outRef) {
   if (!datum) {
@@ -11372,6 +11381,22 @@ function createDestinationDatum(datum, outRef) {
   }
   return Data52.toCBORHex(datum);
 }
+function estimateMinOrderOutputLovelaces(lucid, orderDatum, orderAssets) {
+  const expectedOutputLovelaces = estimateUtxoMinLovelace(
+    lucid.config().protocolParameters,
+    addressToBech323(orderDatum.destination, lucid.config().network),
+    orderAssets,
+    {
+      kind: "inline",
+      value: createDestinationDatum(orderDatum.destinationInlineDatum ?? null, {
+        txHash: "0000000000000000000000000000000000000000000000000000000000000000",
+        outputIndex: 0
+      })
+    }
+  );
+  const roundedExpectedOutputLovelaces = (expectedOutputLovelaces / 1000000n + 1n) * 1000000n;
+  return roundedExpectedOutputLovelaces;
+}
 function psmOrderType(order, sysParams) {
   const iassetAc = {
     currencySymbol: fromHex19(
@@ -11387,28 +11412,56 @@ function psmOrderType(order, sysParams) {
   if (suppliedIasset != 0n && suppliedCollateralAsset != 0n || suppliedIasset == 0n && suppliedCollateralAsset == 0n) {
     return {
       type: "ERROR",
+      errorTag: "VALUE_ERROR",
       reason: "An order must supply either iAsset or collateral asset"
     };
   }
   const isMinting = suppliedCollateralAsset > 0n;
   return isMinting ? { type: "MINTING", suppliedCollateral: suppliedCollateralAsset } : { type: "REDEEMING", suppliedIassets: suppliedIasset };
 }
-function summariseOrder(order, psmPool, sysParams, orderProcessingConfig) {
+function summariseOrder(lucid, order, psmPool, sysParams, psmProcessingConfig) {
+  const config = {
+    ...defaultPSMProcessingConfig,
+    ...psmProcessingConfig
+  };
   const orderType = psmOrderType(order, sysParams);
   if (orderType.type === "ERROR") {
-    return { _tag: "ERROR", reason: orderType.reason };
+    return {
+      _tag: "ERROR",
+      errorTag: orderType.errorTag,
+      description: orderType.reason
+    };
+  }
+  if (toHex19(order.datum.iasset) !== toHex19(psmPool.datum.iasset) || toHex19(order.datum.collateralAsset.currencySymbol) !== toHex19(psmPool.datum.collateralAsset.currencySymbol) || toHex19(order.datum.collateralAsset.tokenName) !== toHex19(psmPool.datum.collateralAsset.tokenName)) {
+    return {
+      _tag: "ERROR",
+      errorTag: "ASSET_MISMATCH",
+      description: "Order - PSM assets mismatch"
+    };
   }
   const isOneToOne = psmPool.datum.collateralToIassetRatio.numerator === psmPool.datum.collateralToIassetRatio.denominator;
-  if (!orderProcessingConfig.ignoreMaxExecutionFeeConstraint && order.datum.maxExecutionFee < BASE_MAX_EXECUTION_FEE) {
+  if (config.enforceMaxExecutionFeeConstraint && order.datum.maxExecutionFee < BASE_MAX_EXECUTION_FEE) {
+    return {
+      _tag: "ERROR",
+      errorTag: "EXECUTION_FEE",
+      description: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`
+    };
+  }
+  if (config.enforceMinLovelaceConstraint && lovelacesAmt5(order.utxo.assets) < estimateMinOrderOutputLovelaces(lucid, order.datum, order.utxo.assets) + order.datum.maxExecutionFee) {
     return {
       _tag: "ERROR",
-      reason: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`
+      errorTag: "INSUFFICIENT_LOVELACES",
+      description: "Order has insufficient lovelaces to cover execution fee and order output."
     };
   }
   if (orderType.type === "MINTING") {
     const suppliedCollateralAsset = orderType.suppliedCollateral;
     if (rationalToFloat(order.datum.maxFeeRatio) < rationalToFloat(psmPool.datum.mintingFeeRatio)) {
-      return { _tag: "ERROR", reason: "Max fee ratio not satisfied" };
+      return {
+        _tag: "ERROR",
+        errorTag: "MAX_FEE",
+        description: "Max fee ratio not satisfied"
+      };
     }
     if (isOneToOne) {
       const fee = calculateFeeFromRatio(
@@ -11472,7 +11525,11 @@ function summariseOrder(order, psmPool, sysParams, orderProcessingConfig) {
   } else {
     const suppliedIasset = orderType.suppliedIassets;
     if (rationalToFloat(order.datum.maxFeeRatio) < rationalToFloat(psmPool.datum.redemptionFeeRatio)) {
-      return { _tag: "ERROR", reason: "Max fee ratio not satisfied" };
+      return {
+        _tag: "ERROR",
+        errorTag: "MAX_FEE",
+        description: "Max fee ratio not satisfied"
+      };
     }
     const fee = calculateFeeFromRatio(
       psmPool.datum.redemptionFeeRatio,
@@ -11537,14 +11594,20 @@ function summariseOrder(order, psmPool, sysParams, orderProcessingConfig) {
     }
   }
 }
-function pickValidSatisfiableOrders(orders, pool, sysParams, orderProcessingConfig) {
+function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessingConfig) {
   const psmAvailableLiq = assetClassValueOf12(
     pool.utxo.assets,
     pool.datum.collateralAsset
   );
   const validOrders = orders.flatMap((order) => {
     try {
-      const res = summariseOrder(order, pool, sysParams, orderProcessingConfig);
+      const res = summariseOrder(
+        lucid,
+        order,
+        pool,
+        sysParams,
+        psmProcessingConfig
+      );
       return res._tag === "SUCCESS" ? [res.result] : [];
     } catch (_) {
       return [];
@@ -11605,16 +11668,16 @@ import {
   fromText as fromText15,
   paymentCredentialOf as paymentCredentialOf3,
   sortUTxOs as sortUTxOs2,
-  toHex as toHex19
+  toHex as toHex20
 } from "@lucid-evolution/lucid";
 import {
   addressFromBech32 as addressFromBech323,
-  addressToBech32 as addressToBech323,
+  addressToBech32 as addressToBech324,
   getInlineDatumOrThrow as getInlineDatumOrThrow6,
   matchSingle as matchSingle7,
   mkAssetsOf as mkAssetsOf16,
   mkLovelacesOf as mkLovelacesOf9,
-  lovelacesAmt as lovelacesAmt5,
+  lovelacesAmt as lovelacesAmt6,
   isSameOutRef as isSameOutRef2,
   assetClassValueOf as assetClassValueOf13
 } from "@3rd-eye-labs/cardano-offchain-common";
@@ -11641,19 +11704,16 @@ async function createStableswapOrder(iasset, collateralAsset, amount, minting, p
     },
     amount
   );
-  const expectedOutputLovelaces = estimateUtxoMinLovelace(
-    lucid.config().protocolParameters,
-    myAddress,
+  const orderAssetsPlusFees = addAssets18(
     assetsToSwap,
-    {
-      kind: "inline",
-      value: createDestinationDatum(destinationInlineDatum ?? null, {
-        txHash: "0000000000000000000000000000000000000000000000000000000000000000",
-        outputIndex: 0
-      })
-    }
+    mkLovelacesOf9(maxExecutionFee),
+    mkLovelacesOf9(additionalLovelaces)
+  );
+  const expectedMinOutputLovelaces = estimateMinOrderOutputLovelaces(
+    lucid,
+    datum,
+    orderAssetsPlusFees
   );
-  const roundedExpectedOutputLovelaces = (expectedOutputLovelaces / 1000000n + 1n) * 1000000n;
   return lucid.newTx().pay.ToContract(
     credentialToAddress6(lucid.config().network, {
       hash: params.validatorHashes.stableswapHash,
@@ -11663,12 +11723,7 @@ async function createStableswapOrder(iasset, collateralAsset, amount, minting, p
       kind: "inline",
       value: serialiseStableswapOrderDatum(datum)
     },
-    addAssets18(
-      assetsToSwap,
-      mkLovelacesOf9(
-        roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces
-      )
-    )
+    addAssets18(orderAssetsPlusFees, mkLovelacesOf9(expectedMinOutputLovelaces))
   );
 }
 async function cancelStableswapOrder(stableswapOrderOref, sysParams, lucid) {
@@ -11690,9 +11745,9 @@ async function cancelStableswapOrder(stableswapOrderOref, sysParams, lucid) {
   return lucid.newTx().readFrom([stableswapScriptRefUtxo]).collectFrom(
     [stableswapOrderUtxo],
     serialiseStableswapOrderRedeemer("CancelStableswapOrder")
-  ).addSignerKey(toHex19(stableswapOrderDatum.owner));
+  ).addSignerKey(toHex20(stableswapOrderDatum.owner));
 }
-async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPoolOref, treasuryOref, sysParams, lucid, orderProcessingConfig = defaultOrderProcessingConfig) {
+async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPoolOref, treasuryOref, sysParams, lucid, psmProcessingConfig) {
   const stableswapScriptRefUtxo = matchSingle7(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -11749,17 +11804,15 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       const orderDatum = parseStableswapOrderDatumOrThrow(
         getInlineDatumOrThrow6(orderUtxo)
       );
-      if (toHex19(orderDatum.iasset) != toHex19(mainOrderDatum.iasset) || toHex19(orderDatum.collateralAsset.currencySymbol) != toHex19(mainOrderDatum.collateralAsset.currencySymbol) || toHex19(orderDatum.collateralAsset.tokenName) != toHex19(mainOrderDatum.collateralAsset.tokenName)) {
-        throw new Error("Wrong batch of orders");
-      }
       const res = summariseOrder(
+        lucid,
         { utxo: orderUtxo, datum: orderDatum },
         { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
         sysParams,
-        orderProcessingConfig
+        psmProcessingConfig
       );
       if (res._tag === "ERROR") {
-        throw new Error(res.reason);
+        throw new Error(res.description);
       }
       return res.result;
     }
@@ -11838,7 +11891,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
           inputs: [orderInfo.order.utxo, mainOrderUtxo]
         }
       ).pay.ToAddressWithData(
-        addressToBech323(
+        addressToBech324(
           orderInfo.order.datum.destination,
           lucid.config().network
         ),
@@ -11853,7 +11906,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
           // NOTICE: Currently, we always take the max execution fee from the order utxo.
           // This can be improved so that we take the actual execution fee.
           mkLovelacesOf9(
-            lovelacesAmt5(orderInfo.order.utxo.assets) - orderInfo.order.datum.maxExecutionFee
+            lovelacesAmt6(orderInfo.order.utxo.assets) - orderInfo.order.datum.maxExecutionFee
           ),
           orderInfo.orderType === "MINTING" ? mkAssetsOf16(iassetAc, orderInfo.swapInfo.owedIasset) : mkAssetsOf16(
             collateralAc,
@@ -11929,7 +11982,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
       value: serialiseStableswapPoolDatum(newStableswapPoolDatum)
     },
     stableswapPool.assets
-  ).addSignerKey(toHex19(stableswapPoolDatum.feeManager)).setMinFee(1038402n);
+  ).addSignerKey(toHex20(stableswapPoolDatum.feeManager)).setMinFee(1038402n);
 }
 export {
   AccountContentSchema,
@@ -12049,7 +12102,6 @@ export {
   createStableswapOrder,
   decodePriceUpdate,
   decodePythMessage,
-  defaultOrderProcessingConfig,
   depositCdp,
   deriveAuthToken,
   derivePythPrice,
@@ -12061,6 +12113,7 @@ export {
   encodePythMessage,
   encodeSignedPythMessage,
   endProposal,
+  estimateMinOrderOutputLovelaces,
   estimateUtxoMinLovelace,
   executeProposal,
   feedInterestOracle,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigo-labs/indigo-sdk",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Indigo SDK for interacting with Indigo endpoints via lucid-evolution",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,7 +31,7 @@
     "@3rd-eye-labs/cardano-offchain-common": "1.4.7",
     "@evolution-sdk/evolution": "^0.3.22",
     "@harmoniclabs/crypto": "^0.3.0",
-    "@lucid-evolution/lucid": "0.6.0",
+    "@lucid-evolution/lucid": "0.6.1",
     "@noble/ed25519": "^3.0.0",
     "@pythnetwork/pyth-lazer-sdk": "^6.0.0",
     "decimal.js": "^10.6.0",

package/scripts/run-repeat.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Usage: ./scripts/run-repeat.sh <n> <command...>
+# Example: ./scripts/run-repeat.sh 100 pnpm test stableswap.test.ts
+
+N=${1:?Usage: $0 <n> <command...>}
+shift
+CMD=("$@")
+
+failures=0
+
+for ((i = 1; i <= N; i++)); do
+  printf "Run %d/%d ... " "$i" "$N"
+  if "${CMD[@]}" > /tmp/run-repeat-out.txt 2>&1; then
+    echo "ok"
+  else
+    echo "FAILED"
+    ((failures++))
+  fi
+done
+
+echo ""
+echo "Done: $((N - failures))/$N passed, $failures failed."

package/src/contracts/stableswap/helpers.ts

@@ -1,4 +1,11 @@
-import { fromHex, fromText, OutRef } from '@lucid-evolution/lucid';
+import {
+  Assets,
+  fromHex,
+  fromText,
+  LucidEvolution,
+  OutRef,
+  toHex,
+} from '@lucid-evolution/lucid';
 import { array as A, ord as Ord, function as F } from 'fp-ts';
 import {
   serialiseStableswapOutputDatum,
@@ -6,7 +13,11 @@ import {
 } from './types-new';
 import { Data } from '@evolution-sdk/evolution';
 import { ParsedOutput } from '../../types/generic';
-import { assetClassValueOf } from '@3rd-eye-labs/cardano-offchain-common';
+import {
+  addressToBech32,
+  assetClassValueOf,
+  lovelacesAmt,
+} from '@3rd-eye-labs/cardano-offchain-common';
 import { SystemParams } from '../../types/system-params';
 import { StableswapPoolContent } from '../cdp/types-new';
 import { calculateFeeFromRatio } from '../../utils/indigo-helpers';
@@ -18,22 +29,30 @@ import {
   rationalToFloat,
 } from '../../types/rational';
 import { BigIntOrd } from '../../utils/bigint-utils';
+import { estimateUtxoMinLovelace } from '../../utils/lucid-utils';
 
 export const BASE_MAX_EXECUTION_FEE = 1_620_000n;
 
-export type OrderProcessConfig = {
+export type PSMProcessingConfig = {
   /**
-   * Whether to ignore that an order has max execution fee set lower
-   * than the threshold (i.e. the processor might be paying the remaining cardano tx fee).
+   * Whether to enforce that an order has max execution fee satisfying
+   * min threshold (i.e. the processor might be paying the remaining cardano tx fee).
    *
-   * The default should be `false`. In case, owner wants to process
-   * such order himself, he can ignore the constraint.
+   * In case, owner wants to process such order himself, he can ignore the constraint.
+   * @default true
    */
-  ignoreMaxExecutionFeeConstraint: boolean;
+  enforceMaxExecutionFeeConstraint?: boolean;
+  /**
+   * Whether to enforce the minimum lovelace constraint. If not enforced,
+   * the processor might need to pay the min lovelace for the order output.
+   * @default true
+   */
+  enforceMinLovelaceConstraint?: boolean;
 };
 
-export const defaultOrderProcessingConfig: OrderProcessConfig = {
-  ignoreMaxExecutionFeeConstraint: false,
+const defaultPSMProcessingConfig: PSMProcessingConfig = {
+  enforceMaxExecutionFeeConstraint: true,
+  enforceMinLovelaceConstraint: true,
 };
 
 export function createDestinationDatum(
@@ -68,6 +87,39 @@ export type StableswapOrderInfo = {
   swapInfo: StableswapInfo;
 };
 
+/**
+ * This is an approximation of the amount of lovelace that will be needed to pay for the output.
+ */
+export function estimateMinOrderOutputLovelaces(
+  lucid: LucidEvolution,
+  orderDatum: StableswapOrderDatum,
+  /**
+   * Including execution fee as well.
+   */
+  orderAssets: Assets,
+): bigint {
+  const expectedOutputLovelaces = estimateUtxoMinLovelace(
+    lucid.config().protocolParameters!,
+    addressToBech32(orderDatum.destination, lucid.config().network!),
+    orderAssets,
+    {
+      kind: 'inline',
+      value: createDestinationDatum(orderDatum.destinationInlineDatum ?? null, {
+        txHash:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        outputIndex: 0,
+      }),
+    },
+  );
+
+  const roundedExpectedOutputLovelaces =
+    (expectedOutputLovelaces / 1_000_000n + 1n) * 1_000_000n;
+
+  return roundedExpectedOutputLovelaces;
+}
+
+type OrderTypeError = 'VALUE_ERROR';
+
 /**
  * Determine the PSM order type.
  */
@@ -77,7 +129,7 @@ export function psmOrderType(
 ):
   | { type: 'MINTING'; suppliedCollateral: bigint }
   | { type: 'REDEEMING'; suppliedIassets: bigint }
-  | { type: 'ERROR'; reason: string } {
+  | { type: 'ERROR'; errorTag: OrderTypeError; reason: string } {
   const iassetAc = {
     currencySymbol: fromHex(
       sysParams.stableswapParams.iassetSymbol.unCurrencySymbol,
@@ -97,6 +149,7 @@ export function psmOrderType(
   ) {
     return {
       type: 'ERROR',
+      errorTag: 'VALUE_ERROR',
       reason: 'An order must supply either iAsset or collateral asset',
     };
   }
@@ -108,36 +161,84 @@ export function psmOrderType(
     : { type: 'REDEEMING', suppliedIassets: suppliedIasset };
 }
 
+type SummaryError =
+  | OrderTypeError
+  | 'ASSET_MISMATCH'
+  | 'EXECUTION_FEE'
+  | 'MAX_FEE'
+  | 'INSUFFICIENT_LOVELACES';
+
 type SummaryResult =
   | { _tag: 'SUCCESS'; result: StableswapOrderInfo }
-  | { _tag: 'ERROR'; reason: string };
+  | { _tag: 'ERROR'; errorTag: SummaryError; description: string };
 
 /**
- * Summarise the order in detail
+ * Summarise the order. Validate all the necessary constraints
+ * for this order to be processed.
  */
 export function summariseOrder(
+  lucid: LucidEvolution,
   order: ParsedOutput<StableswapOrderDatum>,
   psmPool: ParsedOutput<StableswapPoolContent>,
   sysParams: SystemParams,
-  orderProcessingConfig: OrderProcessConfig,
+  psmProcessingConfig?: PSMProcessingConfig,
 ): SummaryResult {
+  const config = {
+    ...defaultPSMProcessingConfig,
+    ...psmProcessingConfig,
+  } satisfies PSMProcessingConfig;
+
   const orderType = psmOrderType(order, sysParams);
 
   if (orderType.type === 'ERROR') {
-    return { _tag: 'ERROR', reason: orderType.reason };
+    return {
+      _tag: 'ERROR',
+      errorTag: orderType.errorTag,
+      description: orderType.reason,
+    };
+  }
+
+  if (
+    toHex(order.datum.iasset) !== toHex(psmPool.datum.iasset) ||
+    toHex(order.datum.collateralAsset.currencySymbol) !==
+      toHex(psmPool.datum.collateralAsset.currencySymbol) ||
+    toHex(order.datum.collateralAsset.tokenName) !==
+      toHex(psmPool.datum.collateralAsset.tokenName)
+  ) {
+    return {
+      _tag: 'ERROR',
+      errorTag: 'ASSET_MISMATCH',
+      description: 'Order - PSM assets mismatch',
+    };
   }
 
   const isOneToOne =
     psmPool.datum.collateralToIassetRatio.numerator ===
     psmPool.datum.collateralToIassetRatio.denominator;
 
+  // TODO: check that the order has enough funds.
   if (
-    !orderProcessingConfig.ignoreMaxExecutionFeeConstraint &&
+    config.enforceMaxExecutionFeeConstraint &&
     order.datum.maxExecutionFee < BASE_MAX_EXECUTION_FEE
   ) {
     return {
       _tag: 'ERROR',
-      reason: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`,
+      errorTag: 'EXECUTION_FEE',
+      description: `Max execution fee is too low. Minimum: ${BASE_MAX_EXECUTION_FEE}`,
+    };
+  }
+
+  if (
+    config.enforceMinLovelaceConstraint &&
+    lovelacesAmt(order.utxo.assets) <
+      estimateMinOrderOutputLovelaces(lucid, order.datum, order.utxo.assets) +
+        order.datum.maxExecutionFee
+  ) {
+    return {
+      _tag: 'ERROR',
+      errorTag: 'INSUFFICIENT_LOVELACES',
+      description:
+        'Order has insufficient lovelaces to cover execution fee and order output.',
     };
   }
 
@@ -148,7 +249,11 @@ export function summariseOrder(
       rationalToFloat(order.datum.maxFeeRatio) <
       rationalToFloat(psmPool.datum.mintingFeeRatio)
     ) {
-      return { _tag: 'ERROR', reason: 'Max fee ratio not satisfied' };
+      return {
+        _tag: 'ERROR',
+        errorTag: 'MAX_FEE',
+        description: 'Max fee ratio not satisfied',
+      };
     }
 
     // Mint order with one to one ratio case.
@@ -228,7 +333,11 @@ export function summariseOrder(
       rationalToFloat(order.datum.maxFeeRatio) <
       rationalToFloat(psmPool.datum.redemptionFeeRatio)
     ) {
-      return { _tag: 'ERROR', reason: 'Max fee ratio not satisfied' };
+      return {
+        _tag: 'ERROR',
+        errorTag: 'MAX_FEE',
+        description: 'Max fee ratio not satisfied',
+      };
     }
 
     const fee = calculateFeeFromRatio(
@@ -306,13 +415,15 @@ export function summariseOrder(
 }
 
 /**
- * Pick only orders that are valid and can be processed based on available liquidity.
+ * Pick only orders that are valid, belong to the PSM pool,
+ * and can be processed based on available liquidity.
  */
 export function pickValidSatisfiableOrders(
+  lucid: LucidEvolution,
   orders: ParsedOutput<StableswapOrderDatum>[],
   pool: ParsedOutput<StableswapPoolContent>,
   sysParams: SystemParams,
-  orderProcessingConfig: OrderProcessConfig,
+  psmProcessingConfig?: PSMProcessingConfig,
 ): ParsedOutput<StableswapOrderDatum>[] {
   const psmAvailableLiq = assetClassValueOf(
     pool.utxo.assets,
@@ -321,7 +432,13 @@ export function pickValidSatisfiableOrders(
 
   const validOrders = orders.flatMap((order) => {
     try {
-      const res = summariseOrder(order, pool, sysParams, orderProcessingConfig);
+      const res = summariseOrder(
+        lucid,
+        order,
+        pool,
+        sysParams,
+        psmProcessingConfig,
+      );
       return res._tag === 'SUCCESS' ? [res.result] : [];
     } catch (_) {
       return [];