@indigo-labs/indigo-sdk 0.4.4 → 0.5.1

package/dist/index.mjs

@@ -6,7 +6,6 @@ import {
   fromHex as fromHex7,
   getInputIndices as getInputIndices3,
   scriptHashToCredential as scriptHashToCredential3,
-  slotToUnixTime as slotToUnixTime5,
   toHex as toHex7
 } from "@lucid-evolution/lucid";
 
@@ -431,16 +430,11 @@ function calculateAccruedInterest(now, unitaryInterestSnapshot, mintedAmount, in
 }
 
 // src/contracts/price-oracle/helpers.ts
-import {
-  slotToUnixTime,
-  unixTimeToSlot
-} from "@lucid-evolution/lucid";
-function oracleExpirationAwareValidity(currentSlot, biasTime, oracleExpiration, network) {
-  const validateFrom = slotToUnixTime(network, currentSlot - 1);
+function oracleExpirationAwareValidity(lucid, biasTime, oracleExpiration) {
+  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
   const defaultValidateTo = validateFrom + biasTime;
-  const cappedValidateTo = slotToUnixTime(
-    network,
-    unixTimeToSlot(network, oracleExpiration) - 1
+  const cappedValidateTo = lucid.slotToUnixTime(
+    lucid.unixTimeToSlot(oracleExpiration) - 1
   );
   const isOracleActuallyExpired = cappedValidateTo <= validateFrom;
   return {
@@ -453,7 +447,6 @@ function oracleExpirationAwareValidity(currentSlot, biasTime, oracleExpiration,
 import { match as match13, P as P13 } from "ts-pattern";
 
 // src/contracts/cdp/helpers.ts
-import { slotToUnixTime as slotToUnixTime2 } from "@lucid-evolution/lucid";
 import { match as match4, P as P4 } from "ts-pattern";
 
 // src/utils/indigo-helpers.ts
@@ -471,11 +464,10 @@ function iassetValueOfCollateral(collateralAmt, oraclePrice) {
     rationalDiv(rationalFromInt(collateralAmt), oraclePrice)
   );
 }
-function cdpCollateralRatioPercentage(currentSlot, iassetPrice, cdpUtxoAssets, cdpContent, interestOracleDatum, network) {
-  const currentTime = BigInt(slotToUnixTime2(network, currentSlot));
+function cdpCollateralRatioPercentage(now, iassetPrice, cdpUtxoAssets, cdpContent, interestOracleDatum) {
   return match4(cdpContent.cdpFees).with({ ActiveCDPInterestTracking: P4.select() }, (interest) => {
     const interestAmt = calculateAccruedInterest(
-      currentTime,
+      now,
       interest.unitaryInterestSnapshot,
       cdpContent.mintedAmt,
       interest.lastSettled,
@@ -1606,7 +1598,6 @@ import {
   toHex as toHex4,
   addAssets as addAssets3,
   fromHex as fromHex3,
-  slotToUnixTime as slotToUnixTime3,
   sortUTxOs,
   getInputIndices as getInputIndices2
 } from "@lucid-evolution/lucid";
@@ -2098,9 +2089,8 @@ function parseCollateralAssetDatumOrThrow(datum) {
 }
 
 // src/contracts/interest-collection/transactions.ts
-async function batchCollectInterest(collateralAssetOref, interestCollectorOutRef, interestOracleOutRef, cdpOutRefs, params, lucid, currentSlot) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime3(network, currentSlot));
+async function batchCollectInterest(collateralAssetOref, interestCollectorOutRef, interestOracleOutRef, cdpOutRefs, params, lucid) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const interestCollectionRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -2196,7 +2186,7 @@ async function batchCollectInterest(collateralAssetOref, interestCollectorOutRef
     referenceInputs,
     false
   );
-  const validateFrom = slotToUnixTime3(network, currentSlot - 1);
+  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
   const validateTo = validateFrom + Number(params.cdpParams.biasTime);
   const tx = lucid.newTx().validFrom(validateFrom).validTo(validateTo).readFrom(referenceInputs).collectFrom([interestCollectorUtxo], {
     kind: "selected",
@@ -3246,7 +3236,6 @@ import {
   Data as Data18,
   fromHex as fromHex6,
   scriptHashToCredential as scriptHashToCredential2,
-  slotToUnixTime as slotToUnixTime4,
   toHex as toHex6
 } from "@lucid-evolution/lucid";
 import { match as match11, P as P11 } from "ts-pattern";
@@ -3743,11 +3732,9 @@ function derivePythPrice(derivedPythPrice, messageHex) {
 // src/contracts/iasset/helpers.ts
 import * as Core from "@evolution-sdk/evolution";
 var MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET = 9;
-function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythStateOref, pythMessage, pythConfig, biasTime, currentSlot, lucid, tx) {
+function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythStateOref, pythMessage, pythConfig, biasTime, lucid, tx) {
   return match11(priceInfo).returnType().with({ Delisted: P11.any }, () => {
-    const currentTime = BigInt(
-      slotToUnixTime4(lucid.config().network, currentSlot)
-    );
+    const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
     const validFrom = Number(currentTime - BigInt(biasTime / 2n));
     const validTo = Number(currentTime + BigInt(biasTime / 2n));
     return Promise.resolve({
@@ -3768,10 +3755,9 @@ function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythS
     );
     return {
       interval: oracleExpirationAwareValidity(
-        currentSlot,
+        lucid,
         Number(biasTime),
-        Number(priceOracleDatum.expirationTime),
-        lucid.config().network
+        Number(priceOracleDatum.expirationTime)
       ),
       referenceInputs: [priceOracleUtxo]
     };
@@ -3875,9 +3861,9 @@ async function retrieveAdjustedPrice(iasset, collateralAsset, priceInfo, extraDe
 }
 
 // src/contracts/cdp/transactions.ts
-async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, lucid, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, lucid, pythMessage = void 0, pythStateOref = void 0) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime5(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const [pkh, skh] = await addrDetails(lucid);
   const cdpCreatorRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -3999,7 +3985,6 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     pythMessage,
     sysParams.pythConfig,
     sysParams.cdpCreatorParams.biasTime,
-    currentSlot,
     lucid,
     tx
   );
@@ -4047,9 +4032,8 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
   });
   return tx;
 }
-async function adjustCdp(collateralAdjustment, debtAdjustment, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, sysParams, lucid, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime5(network, currentSlot));
+async function adjustCdp(collateralAdjustment, debtAdjustment, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, sysParams, lucid, pythMessage = void 0, pythStateOref = void 0) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -4115,7 +4099,6 @@ async function adjustCdp(collateralAdjustment, debtAdjustment, cdpOref, iassetOr
       pythMessage,
       sysParams.pythConfig,
       sysParams.cdpParams.biasTime,
-      currentSlot,
       lucid,
       tx
     );
@@ -4210,7 +4193,7 @@ async function adjustCdp(collateralAdjustment, debtAdjustment, cdpOref, iassetOr
   tx.addSignerKey(toHex7(cdpDatum.cdpOwner));
   return tx;
 }
-async function depositCdp(amount, cdpOref, iassetOref, collateralAssetOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, currentSlot) {
+async function depositCdp(amount, cdpOref, iassetOref, collateralAssetOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid) {
   return adjustCdp(
     amount,
     0n,
@@ -4222,11 +4205,10 @@ async function depositCdp(amount, cdpOref, iassetOref, collateralAssetOref, inte
     treasuryOref,
     interestCollectorOref,
     params,
-    lucid,
-    currentSlot
+    lucid
   );
 }
-async function withdrawCdp(amount, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+async function withdrawCdp(amount, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, pythMessage = void 0, pythStateOref = void 0) {
   return adjustCdp(
     -amount,
     0n,
@@ -4239,12 +4221,11 @@ async function withdrawCdp(amount, cdpOref, iassetOref, collateralAssetOref, pri
     interestCollectorOref,
     params,
     lucid,
-    currentSlot,
     pythMessage,
     pythStateOref
   );
 }
-async function mintCdp(amount, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+async function mintCdp(amount, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, pythMessage = void 0, pythStateOref = void 0) {
   return adjustCdp(
     0n,
     amount,
@@ -4257,12 +4238,11 @@ async function mintCdp(amount, cdpOref, iassetOref, collateralAssetOref, priceOr
     interestCollectorOref,
     params,
     lucid,
-    currentSlot,
     pythMessage,
     pythStateOref
   );
 }
-async function burnCdp(amount, cdpOref, iassetOref, collateralAssetOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid, currentSlot) {
+async function burnCdp(amount, cdpOref, iassetOref, collateralAssetOref, interestOracleOref, treasuryOref, interestCollectorOref, params, lucid) {
   return adjustCdp(
     0n,
     -amount,
@@ -4274,13 +4254,11 @@ async function burnCdp(amount, cdpOref, iassetOref, collateralAssetOref, interes
     treasuryOref,
     interestCollectorOref,
     params,
-    lucid,
-    currentSlot
+    lucid
   );
 }
-async function closeCdp(cdpOref, collateralAssetOref, interestOracleOref, interestCollectorOref, sysParams, lucid, currentSlot) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime5(network, currentSlot));
+async function closeCdp(cdpOref, collateralAssetOref, interestOracleOref, interestCollectorOref, sysParams, lucid) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -4322,7 +4300,7 @@ async function closeCdp(cdpOref, collateralAssetOref, interestOracleOref, intere
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
   );
-  const validateFrom = slotToUnixTime5(network, currentSlot - 1);
+  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
   const validateTo = validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
   const tx = lucid.newTx().readFrom([
     cdpRefScriptUtxo,
@@ -4380,9 +4358,8 @@ async function closeCdp(cdpOref, collateralAssetOref, interestOracleOref, intere
   }
   return tx;
 }
-async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, interestCollectorOref, treasuryOref, govOref, sysParams, lucid, currentSlot, pythMessage = void 0, _pythStateOref = void 0) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime5(network, currentSlot));
+async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, interestCollectorOref, treasuryOref, govOref, sysParams, lucid, pythMessage = void 0, _pythStateOref = void 0) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -4512,15 +4489,14 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, coll
       getInlineDatumOrThrow(priceOracleUtxo)
     );
     const txValidity = oracleExpirationAwareValidity(
-      currentSlot,
+      lucid,
       Number(sysParams.cdpCreatorParams.biasTime),
-      Number(priceOracleDatum.expirationTime),
-      network
+      Number(priceOracleDatum.expirationTime)
     );
     referenceInputs.push(priceOracleUtxo);
     tx.validFrom(txValidity.validFrom).validTo(txValidity.validTo);
   } else {
-    const validateFrom = slotToUnixTime5(network, currentSlot - 1);
+    const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
     const validateTo = validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
     tx.validFrom(validateFrom).validTo(validateTo);
   }
@@ -4632,9 +4608,9 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, coll
   );
   return tx;
 }
-async function freezeCdp(cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, sysParams, lucid, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+async function freezeCdp(cdpOref, iassetOref, collateralAssetOref, priceOracleOref, interestOracleOref, sysParams, lucid, pythMessage = void 0, pythStateOref = void 0) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime5(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -4717,7 +4693,6 @@ async function freezeCdp(cdpOref, iassetOref, collateralAssetOref, priceOracleOr
     pythMessage,
     sysParams.pythConfig,
     sysParams.cdpParams.biasTime,
-    currentSlot,
     lucid,
     tx
   );
@@ -5317,7 +5292,6 @@ import {
   fromHex as fromHex8,
   fromText as fromText4,
   paymentCredentialOf as paymentCredentialOf2,
-  slotToUnixTime as slotToUnixTime6,
   toHex as toHex8
 } from "@lucid-evolution/lucid";
 import {
@@ -5770,9 +5744,9 @@ import {
   addressFromBech32,
   addressToBech32
 } from "@3rd-eye-labs/cardano-offchain-common";
-async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
+async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, govOref, allIAssetOrefs) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const pkh = paymentCredentialOf2(ownAddr);
   const govRefScriptUtxo = matchSingle(
@@ -5891,9 +5865,9 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
     newPollId
   ];
 }
-async function createShardsChunks(chunkSize, pollManagerOref, sysParams, currentSlot, lucid) {
+async function createShardsChunks(chunkSize, pollManagerOref, sysParams, lucid) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const pollManagerUtxo = matchSingle(
     await lucid.utxosByOutRef([pollManagerOref]),
@@ -5982,9 +5956,8 @@ function voteHelper(stakingPosLockedAmt, pollShard, voteOption, currentTime, ind
   ];
   return [newLockedAmt, newPollStatus];
 }
-async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, lucid, currentSlot) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, lucid) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const pollShardRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -6030,7 +6003,10 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     indyStakedAmt
   );
   return lucid.newTx().validFrom(validityFrom).validTo(
-    validityFrom + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Math.min(
+      validityFrom + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND,
+      Number(pollShardDatum.votingEndTime) - ONE_SECOND
+    )
   ).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
     [pollShardUtxo],
     serialisePollShardRedeemer({ Vote: voteOption })
@@ -6058,9 +6034,8 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     stakingPosUtxo.assets
   ).addSigner(ownAddr);
 }
-async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, currentSlot) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const pollShardRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -6147,9 +6122,9 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     addAssets8(pollManagerUtxo.assets, shardsAggregatedAda)
   ).addSigner(ownAddr);
 }
-async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSlot) {
+async function endProposal(pollManagerOref, govOref, sysParams, lucid) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const pollManagerRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -6261,9 +6236,9 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
   }
   return tx;
 }
-async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, allIAssetOrefs, iAssetOref, allCollateralAssetsOrefsOfIAsset, collateralAssetOref, stableswapPoolOrCdpCreatorOref, sysParams, lucid, currentSlot) {
+async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, allIAssetOrefs, iAssetOref, allCollateralAssetsOrefsOfIAsset, collateralAssetOref, stableswapPoolOrCdpCreatorOref, sysParams, lucid) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const ownAddr = await lucid.wallet().address();
   const govUtxo = matchSingle(
     await lucid.utxosByOutRef([govOref]),
@@ -6998,7 +6973,6 @@ import {
   Data as Data32,
   fromHex as fromHex9,
   fromText as fromText5,
-  slotToUnixTime as slotToUnixTime7,
   toHex as toHex9
 } from "@lucid-evolution/lucid";
 import {
@@ -7068,9 +7042,8 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     }
   ).addSignerKey(pkh.hash);
 }
-async function adjustStakingPosition(stakingPositionRef, amount, params, lucid, currentSlot, stakingManagerRef) {
-  const network = lucid.config().network;
-  const now = BigInt(slotToUnixTime7(network, currentSlot));
+async function adjustStakingPosition(stakingPositionRef, amount, params, lucid, stakingManagerRef) {
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const stakingPositionOut = await findStakingPositionByOutRef(
     stakingPositionRef,
     lucid
@@ -7125,9 +7098,8 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
     addAssets9(stakingPositionOut.utxo.assets, mkAssetsOf7(indyToken, amount))
   ).addSignerKey(toHex9(stakingPositionOut.datum.owner));
 }
-async function closeStakingPosition(stakingPositionRef, params, lucid, currentSlot, stakingManagerRef) {
-  const network = lucid.config().network;
-  const now = BigInt(slotToUnixTime7(network, currentSlot));
+async function closeStakingPosition(stakingPositionRef, params, lucid, stakingManagerRef) {
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const stakingPositionOut = await findStakingPositionByOutRef(
     stakingPositionRef,
     lucid
@@ -7249,7 +7221,6 @@ function castStakingParams(params) {
 import {
   fromHex as fromHex10,
   fromText as fromText6,
-  slotToUnixTime as slotToUnixTime8,
   toUnit as toUnit2,
   validatorToAddress
 } from "@lucid-evolution/lucid";
@@ -7431,14 +7402,13 @@ async function startInterestOracle(initialUnitaryInterest, initialInterestRate,
     }
   ];
 }
-async function feedInterestOracle(params, newInterestRate, lucid, currentSlot, assetClass, utxo, scriptRef2) {
+async function feedInterestOracle(params, newInterestRate, lucid, assetClass, utxo, scriptRef2) {
   if (!assetClass && !utxo)
     throw new Error("Either interest oracle nft or utxo must be provided");
   if (assetClass && !utxo) {
     utxo = await findInterestOracle(lucid, assetClass);
   }
-  const network = lucid.config().network;
-  const now = BigInt(slotToUnixTime8(network, currentSlot));
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const tx = lucid.newTx();
   const datum = parseInterestOracleDatum(getInlineDatumOrThrow(utxo));
   if (scriptRef2) {
@@ -7962,7 +7932,6 @@ import {
   fromHex as fromHex11,
   toHex as toHex12,
   addAssets as addAssets11,
-  slotToUnixTime as slotToUnixTime9,
   credentialToAddress as credentialToAddress3
 } from "@lucid-evolution/lucid";
 import {
@@ -8129,9 +8098,8 @@ async function requestSpAccountClosure(accountUtxo, sysParams, lucid, maxTxFee =
     )
   ).addSignerKey(toHex12(oldAccountDatum.owner));
 }
-async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, currentSlot, txFee) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime9(network, currentSlot));
+async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, txFee) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const stabilityPoolScriptRef = matchSingle5(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -8147,7 +8115,7 @@ async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetU
     getInlineDatumOrThrow(stabilityPoolUtxo)
   );
   const baseRefInputs = [iAssetUtxo, stabilityPoolScriptRef];
-  const validFrom = slotToUnixTime9(network, currentSlot - 1);
+  const validFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
   const tx = lucid.newTx().validFrom(validFrom).validTo(validFrom + sysParams.stabilityPoolParams.accountProcessingBiasMs).readFrom(baseRefInputs).collectFrom([stabilityPoolUtxo], {
     kind: "selected",
     inputs: [stabilityPoolUtxo, accountUtxo],
@@ -8519,7 +8487,7 @@ async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetU
   }).exhaustive();
   return tx;
 }
-async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, currentSlot) {
+async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid) {
   const draftTx = processSpRequestAuxiliary(
     stabilityPoolUtxo,
     accountUtxo,
@@ -8527,7 +8495,6 @@ async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    currentSlot,
     // Placeholder transation fee
     1n
   );
@@ -8539,7 +8506,6 @@ async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    currentSlot,
     fee
   );
 }
@@ -9176,7 +9142,7 @@ async function cancelRob(robOutRef, sysParams, lucid) {
   const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
   return lucid.newTx().readFrom([robScriptRefUtxo]).collectFrom([robUtxo], serialiseRobRedeemer("Cancel")).addSignerKey(toHex14(robDatum.owner));
 }
-async function redeemRob(redemptionRobsData, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, lucid, sysParams, currentSlot, pythMessage = void 0, pythStateOutRef = void 0) {
+async function redeemRob(redemptionRobsData, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, lucid, sysParams, pythMessage = void 0, pythStateOutRef = void 0) {
   const robScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef)
@@ -9220,7 +9186,6 @@ async function redeemRob(redemptionRobsData, priceOracleOutRef, iassetOutRef, co
     pythMessage,
     sysParams.pythConfig,
     sysParams.cdpParams.biasTime,
-    currentSlot,
     lucid,
     tx
   );
@@ -9394,7 +9359,6 @@ var mkRobValidatorFromSP = (params) => {
 // src/contracts/rob-leverage/transactions.ts
 import {
   addAssets as addAssets14,
-  slotToUnixTime as slotToUnixTime10,
   Data as Data45,
   fromHex as fromHex14,
   getInputIndices as getInputIndices5
@@ -9580,9 +9544,9 @@ function calculateLeverageFromCollateralRatio(iasset, collateralAsset, collatera
 // src/contracts/rob-leverage/transactions.ts
 import { mkAssetsOf as mkAssetsOf11 } from "@3rd-eye-labs/cardano-offchain-common";
 import Decimal3 from "decimal.js";
-async function leverageCdpWithRob(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, cdpCreatorOref, interestOracleOref, treasuryOref, sysParams, lucid, allRobs, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+async function leverageCdpWithRob(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, cdpCreatorOref, interestOracleOref, treasuryOref, sysParams, lucid, allRobs, pythMessage = void 0, pythStateOref = void 0) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime10(network, currentSlot));
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const [pkh, skh] = await addrDetails(lucid);
   const robScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -9776,7 +9740,6 @@ async function leverageCdpWithRob(leverage, baseCollateral, priceOracleOutRef, i
     pythMessage,
     sysParams.pythConfig,
     sysParams.cdpCreatorParams.biasTime,
-    currentSlot,
     lucid,
     tx
   );
@@ -9834,7 +9797,6 @@ import {
   Data as Data46,
   fromHex as fromHex15,
   fromText as fromText10,
-  slotToUnixTime as slotToUnixTime11,
   validatorToAddress as validatorToAddress2
 } from "@lucid-evolution/lucid";
 
@@ -9863,9 +9825,8 @@ function mkPriceOracleValidator(params) {
 // src/contracts/price-oracle/transactions.ts
 import { mkAssetsOf as mkAssetsOf12 } from "@3rd-eye-labs/cardano-offchain-common";
 import * as Core2 from "@evolution-sdk/evolution";
-async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, currentSlot, refOutRef, auxiliaryData) {
-  const network = lucid.config().network;
-  const now = BigInt(slotToUnixTime11(network, currentSlot));
+async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, refOutRef, auxiliaryData) {
+  const now = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   if (!refOutRef) {
     refOutRef = (await lucid.wallet().getUtxos())[0];
   }
@@ -9898,9 +9859,8 @@ async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, cu
   );
   return [tx, priceOracleNft];
 }
-async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, currentSlot, auxiliaryData) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime11(network, currentSlot));
+async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, auxiliaryData) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const priceOracleUtxo = matchSingle(
     await lucid.utxosByOutRef([oracleOref]),
     (_) => new Error("Expected a single price oracle UTXO")
@@ -10214,7 +10174,7 @@ async function initStakingManager(lucid, stakingParams) {
   );
   await submitTx(lucid, tx);
 }
-async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, pythConfig, currentSlot) {
+async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, pythConfig) {
   return match20(collateralAsset.priceOracle).returnType().with({ tag: "_indigo_oracle_nft" }, async (val) => {
     const [pkh, _] = await addrDetails(lucid);
     const priceOracleParams = {
@@ -10226,8 +10186,7 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
       lucid,
       val.tokenName,
       val.startPrice,
-      priceOracleParams,
-      currentSlot
+      priceOracleParams
     );
     await runAndAwaitTxBuilder(lucid, priceOracleStartTx);
     return { info: { OracleNft: priceOracleNft }, params: priceOracleParams };
@@ -10248,7 +10207,7 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
     });
   }).exhaustive();
 }
-async function initializeAsset(lucid, iassetParams, iassetToken, collateralAssetAuthToken, cdpAuthToken, cdpParams, stableswapValidatorHash, stabilityPoolParams, stabilityPoolToken, asset, pythConfig, currentSlot) {
+async function initializeAsset(lucid, iassetParams, iassetToken, collateralAssetAuthToken, cdpAuthToken, cdpParams, stableswapValidatorHash, stabilityPoolParams, stabilityPoolToken, asset, pythConfig) {
   const iassetName = fromHex16(fromText11(asset.name));
   const collateralAssetInfos = [];
   for (const collateralAsset of asset.collateralAssets) {
@@ -10270,8 +10229,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       lucid,
       asset,
       collateralAsset,
-      pythConfig,
-      currentSlot
+      pythConfig
     );
     const collateralAssetContent = {
       iasset: iassetName,
@@ -10672,7 +10630,7 @@ async function initPythConfig(lucid, initialAssets, pythStateAsset) {
     pythFeeds: allPythFeeds
   };
 }
-async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets = () => [], protocolParams, initOptions, spStakingCred = DEFAULT_STAKING_CRED, treasuryStakingCred = DEFAULT_STAKING_CRED) {
+async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], protocolParams, initOptions, spStakingCred = DEFAULT_STAKING_CRED, treasuryStakingCred = DEFAULT_STAKING_CRED) {
   const startSlot = lucid.currentSlot();
   const {
     totalIndySupply,
@@ -10972,8 +10930,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
           stabilityPoolParams,
           stabilityPoolToken,
           asset,
-          pythConfig,
-          currentSlot
+          pythConfig
         );
         assetInfos.push(assetInfo);
       }
@@ -11293,7 +11250,12 @@ 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
 import {
@@ -11397,7 +11359,16 @@ function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
 
 // src/contracts/stableswap/helpers.ts
 import { Data as Data52 } from "@evolution-sdk/evolution";
+import {
+  addressToBech32 as addressToBech323,
+  assetClassValueOf as assetClassValueOf12,
+  lovelacesAmt as lovelacesAmt5
+} from "@3rd-eye-labs/cardano-offchain-common";
 var BASE_MAX_EXECUTION_FEE = 1620000n;
+var defaultPSMProcessingConfig = {
+  enforceMaxExecutionFeeConstraint: true,
+  enforceMinLovelaceConstraint: true
+};
 function createDestinationDatum(datum, outRef) {
   if (!datum) {
     return serialiseStableswapOutputDatum([
@@ -11410,6 +11381,283 @@ 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(
+      sysParams.stableswapParams.iassetSymbol.unCurrencySymbol
+    ),
+    tokenName: order.datum.iasset
+  };
+  const suppliedIasset = assetClassValueOf12(order.utxo.assets, iassetAc);
+  const suppliedCollateralAsset = assetClassValueOf12(
+    order.utxo.assets,
+    order.datum.collateralAsset
+  );
+  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(lucid, order, psmPool, sysParams, psmProcessingConfig) {
+  const config = {
+    ...defaultPSMProcessingConfig,
+    ...psmProcessingConfig
+  };
+  const orderType = psmOrderType(order, sysParams);
+  if (orderType.type === "ERROR") {
+    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 (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",
+      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",
+        errorTag: "MAX_FEE",
+        description: "Max fee ratio not satisfied"
+      };
+    }
+    if (isOneToOne) {
+      const fee = calculateFeeFromRatio(
+        psmPool.datum.mintingFeeRatio,
+        suppliedCollateralAsset
+      );
+      return {
+        _tag: "SUCCESS",
+        result: {
+          order,
+          orderType: "MINTING",
+          swapInfo: {
+            suppliedCollateralAsset,
+            suppliedIasset: 0n,
+            owedCollateralAsset: 0n,
+            owedIasset: suppliedCollateralAsset - fee,
+            mintingFee: fee,
+            redemptionFee: 0n
+          }
+        }
+      };
+    } else {
+      const iAssetConversion = rationalFloor(
+        rationalDiv(
+          rationalFromInt(suppliedCollateralAsset),
+          psmPool.datum.collateralToIassetRatio
+        )
+      );
+      const attemptedNormalizedCollateral = rationalFloor(
+        rationalMul(
+          rationalFromInt(iAssetConversion),
+          psmPool.datum.collateralToIassetRatio
+        )
+      );
+      const normalizedCollateralSupplied = rationalFloor(
+        rationalDiv(
+          rationalFromInt(attemptedNormalizedCollateral),
+          psmPool.datum.collateralToIassetRatio
+        )
+      ) != iAssetConversion ? suppliedCollateralAsset : attemptedNormalizedCollateral;
+      const fee = calculateFeeFromRatio(
+        psmPool.datum.mintingFeeRatio,
+        iAssetConversion
+      );
+      return {
+        _tag: "SUCCESS",
+        result: {
+          order,
+          orderType: "MINTING",
+          swapInfo: {
+            suppliedCollateralAsset: normalizedCollateralSupplied,
+            suppliedIasset: 0n,
+            owedIasset: iAssetConversion - fee,
+            owedCollateralAsset: 0n,
+            mintingFee: fee,
+            redemptionFee: 0n
+          }
+        }
+      };
+    }
+  } else {
+    const suppliedIasset = orderType.suppliedIassets;
+    if (rationalToFloat(order.datum.maxFeeRatio) < rationalToFloat(psmPool.datum.redemptionFeeRatio)) {
+      return {
+        _tag: "ERROR",
+        errorTag: "MAX_FEE",
+        description: "Max fee ratio not satisfied"
+      };
+    }
+    const fee = calculateFeeFromRatio(
+      psmPool.datum.redemptionFeeRatio,
+      suppliedIasset
+    );
+    const effectiveSuppliedIasset = suppliedIasset - fee;
+    if (isOneToOne) {
+      return {
+        _tag: "SUCCESS",
+        result: {
+          order,
+          orderType: "REDEEMING",
+          swapInfo: {
+            suppliedIasset: effectiveSuppliedIasset,
+            suppliedCollateralAsset: 0n,
+            owedCollateralAsset: effectiveSuppliedIasset,
+            owedIasset: 0n,
+            redemptionFee: fee,
+            mintingFee: 0n
+          }
+        }
+      };
+    } else {
+      const collateralConversion = rationalFloor(
+        rationalMul(
+          rationalFromInt(effectiveSuppliedIasset),
+          psmPool.datum.collateralToIassetRatio
+        )
+      );
+      const attemptedNormalizedEffectiveIasset = rationalFloor(
+        rationalDiv(
+          rationalFromInt(collateralConversion),
+          psmPool.datum.collateralToIassetRatio
+        )
+      );
+      const normalizedEffectiveIasset = rationalFloor(
+        rationalMul(
+          rationalFromInt(attemptedNormalizedEffectiveIasset),
+          psmPool.datum.collateralToIassetRatio
+        )
+      ) != collateralConversion ? effectiveSuppliedIasset : attemptedNormalizedEffectiveIasset;
+      return {
+        _tag: "SUCCESS",
+        result: {
+          order,
+          orderType: "REDEEMING",
+          swapInfo: {
+            suppliedIasset: normalizedEffectiveIasset,
+            suppliedCollateralAsset: 0n,
+            owedCollateralAsset: rationalFloor(
+              rationalMul(
+                rationalFromInt(effectiveSuppliedIasset),
+                psmPool.datum.collateralToIassetRatio
+              )
+            ),
+            owedIasset: 0n,
+            redemptionFee: fee,
+            mintingFee: 0n
+          }
+        }
+      };
+    }
+  }
+}
+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(
+        lucid,
+        order,
+        pool,
+        sysParams,
+        psmProcessingConfig
+      );
+      return res._tag === "SUCCESS" ? [res.result] : [];
+    } catch (_) {
+      return [];
+    }
+  });
+  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = F27.pipe(
+    validOrders,
+    A16.partition((o) => o.orderType === "REDEEMING"),
+    ({ left, right }) => ({
+      left,
+      // Sort the redeeming orders descending.
+      right: F27.pipe(
+        right,
+        A16.sort(
+          Ord5.contramap(
+            (o) => o.swapInfo.owedCollateralAsset
+          )(Ord5.reverse(BigIntOrd))
+        )
+      )
+    })
+  );
+  const totalCollateralDiff = F27.pipe(
+    validOrders,
+    A16.reduce(
+      0n,
+      (acc, order) => acc + order.swapInfo.suppliedCollateralAsset - order.swapInfo.owedCollateralAsset
+    )
+  );
+  if (psmAvailableLiq + totalCollateralDiff >= 0n) {
+    return validOrders.map((o) => o.order);
+  }
+  const collateralFromMinting = F27.pipe(
+    mintingOrders,
+    A16.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset)
+  );
+  const { selected } = F27.pipe(
+    redeemingOrdersSortedDesc,
+    A16.reduce(
+      {
+        intermediateCollateralAmt: psmAvailableLiq + collateralFromMinting,
+        selected: []
+      },
+      ({ intermediateCollateralAmt, selected: selected2 }, order) => intermediateCollateralAmt >= order.swapInfo.owedCollateralAsset ? {
+        intermediateCollateralAmt: intermediateCollateralAmt - order.swapInfo.owedCollateralAsset,
+        selected: [...selected2, order]
+      } : { intermediateCollateralAmt, selected: selected2 }
+    )
+  );
+  return [...mintingOrders, ...selected].map((o) => o.order);
+}
 
 // src/contracts/stableswap/transactions.ts
 import {
@@ -11420,20 +11668,20 @@ 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 assetClassValueOf12
+  assetClassValueOf as assetClassValueOf13
 } from "@3rd-eye-labs/cardano-offchain-common";
-import { array as A16, function as F27 } from "fp-ts";
+import { array as A17, function as F28 } from "fp-ts";
 import { isEmpty } from "fp-ts/lib/Array";
 async function createStableswapOrder(iasset, collateralAsset, amount, minting, poolDatum, params, lucid, destinationAddress, destinationInlineDatum, maxExecutionFee = BASE_MAX_EXECUTION_FEE, additionalLovelaces = 0n, maxFeeRatio) {
   const myAddress = await lucid.wallet().address();
@@ -11456,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,
@@ -11478,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) {
@@ -11505,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) {
+async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPoolOref, treasuryOref, sysParams, lucid, psmProcessingConfig) {
   const stableswapScriptRefUtxo = matchSingle7(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -11564,137 +11804,22 @@ 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 suppliedIasset = assetClassValueOf12(orderUtxo.assets, iassetAc);
-      const suppliedCollateralAsset = assetClassValueOf12(
-        orderUtxo.assets,
-        collateralAc
+      const res = summariseOrder(
+        lucid,
+        { utxo: orderUtxo, datum: orderDatum },
+        { utxo: stableswapPoolUtxo, datum: stableswapPoolDatum },
+        sysParams,
+        psmProcessingConfig
       );
-      if (suppliedIasset != 0n && suppliedCollateralAsset != 0n || suppliedIasset == 0n && suppliedCollateralAsset == 0n) {
-        throw new Error(
-          "An order must supply either iAsset or collateral asset"
-        );
-      }
-      const isMinting = suppliedCollateralAsset > 0n;
-      const isOneToOne = stableswapPoolDatum.collateralToIassetRatio.numerator === stableswapPoolDatum.collateralToIassetRatio.denominator;
-      if (isMinting) {
-        if (isOneToOne) {
-          const fee2 = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            suppliedCollateralAsset
-          );
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset,
-              suppliedIasset: 0n,
-              owedCollateralAsset: 0n,
-              owedIasset: suppliedCollateralAsset - fee2,
-              mintingFee: fee2,
-              redemptionFee: 0n
-            }
-          };
-        } else {
-          const iAssetConversion = rationalFloor(
-            rationalDiv(
-              rationalFromInt(suppliedCollateralAsset),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          );
-          const attemptedNormalizedCollateral = rationalFloor(
-            rationalMul(
-              rationalFromInt(iAssetConversion),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          );
-          const normalizedCollateralSupplied = rationalFloor(
-            rationalDiv(
-              rationalFromInt(attemptedNormalizedCollateral),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          ) != iAssetConversion ? suppliedCollateralAsset : attemptedNormalizedCollateral;
-          const fee2 = calculateFeeFromRatio(
-            stableswapPoolDatum.mintingFeeRatio,
-            iAssetConversion
-          );
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: normalizedCollateralSupplied,
-              suppliedIasset: 0n,
-              owedCollateralAsset: 0n,
-              owedIasset: iAssetConversion - fee2,
-              mintingFee: fee2,
-              redemptionFee: 0n
-            }
-          };
-        }
-      } else {
-        const fee2 = calculateFeeFromRatio(
-          stableswapPoolDatum.redemptionFeeRatio,
-          suppliedIasset
-        );
-        const effectiveSuppliedIasset = suppliedIasset - fee2;
-        if (isOneToOne) {
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: effectiveSuppliedIasset,
-              owedCollateralAsset: effectiveSuppliedIasset,
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee2
-            }
-          };
-        } else {
-          const collateralConversion = rationalFloor(
-            rationalMul(
-              rationalFromInt(effectiveSuppliedIasset),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          );
-          const attemptedNormalizedEffectiveIasset = rationalFloor(
-            rationalDiv(
-              rationalFromInt(collateralConversion),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          );
-          const normalizedEffectiveIasset = rationalFloor(
-            rationalMul(
-              rationalFromInt(attemptedNormalizedEffectiveIasset),
-              stableswapPoolDatum.collateralToIassetRatio
-            )
-          ) != collateralConversion ? effectiveSuppliedIasset : attemptedNormalizedEffectiveIasset;
-          return {
-            utxo: orderUtxo,
-            datum: orderDatum,
-            swapInfo: {
-              suppliedCollateralAsset: 0n,
-              suppliedIasset: normalizedEffectiveIasset,
-              owedCollateralAsset: rationalFloor(
-                rationalMul(
-                  rationalFromInt(effectiveSuppliedIasset),
-                  stableswapPoolDatum.collateralToIassetRatio
-                )
-              ),
-              owedIasset: 0n,
-              mintingFee: 0n,
-              redemptionFee: fee2
-            }
-          };
-        }
+      if (res._tag === "ERROR") {
+        throw new Error(res.description);
       }
+      return res.result;
     }
   );
-  const totalSwapInfo = F27.pipe(
+  const totalSwapInfo = F28.pipe(
     ordersInfo,
-    A16.reduce(
+    A17.reduce(
       {
         suppliedCollateralAsset: 0n,
         suppliedIasset: 0n,
@@ -11716,6 +11841,13 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     )
   );
   const collateralAmtChangePool = totalSwapInfo.suppliedCollateralAsset - totalSwapInfo.owedCollateralAsset;
+  const newPsmPoolValue = addAssets18(
+    stableswapPoolUtxo.assets,
+    mkAssetsOf16(collateralAc, collateralAmtChangePool)
+  );
+  if (assetClassValueOf13(newPsmPoolValue, collateralAc) < 0n) {
+    throw new Error("Cannot batch more than liquidity allows");
+  }
   const amountToMint = totalSwapInfo.owedIasset - totalSwapInfo.suppliedIasset + totalSwapInfo.mintingFee;
   const fee = totalSwapInfo.mintingFee + totalSwapInfo.redemptionFee;
   const tx = lucid.newTx().readFrom([
@@ -11736,20 +11868,17 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       kind: "inline",
       value: serialiseStableswapPoolDatum(stableswapPoolDatum)
     },
-    collateralAmtChangePool != 0n ? addAssets18(
-      stableswapPoolUtxo.assets,
-      mkAssetsOf16(collateralAc, collateralAmtChangePool)
-    ) : stableswapPoolUtxo.assets
+    newPsmPoolValue
   ).setMinFee(stableswapOrderOrefs.length > 1 ? 1498875n : 1030000n);
   if (amountToMint !== 0n) {
     tx.mintAssets(mkAssetsOf16(iassetAc, amountToMint), Data53.void());
   }
-  F27.pipe(
+  F28.pipe(
     ordersInfo,
-    A16.reduce(tx, (acc, orderInfo) => {
+    A17.reduce(tx, (acc, orderInfo) => {
       return acc.collectFrom(
-        [orderInfo.utxo],
-        isSameOutRef2(orderInfo.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
+        [orderInfo.order.utxo],
+        isSameOutRef2(orderInfo.order.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
           kind: "selected",
           makeRedeemer: (inputIndices) => {
             return serialiseStableswapOrderRedeemer({
@@ -11759,24 +11888,27 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
               }
             });
           },
-          inputs: [orderInfo.utxo, mainOrderUtxo]
+          inputs: [orderInfo.order.utxo, mainOrderUtxo]
         }
       ).pay.ToAddressWithData(
-        addressToBech323(orderInfo.datum.destination, lucid.config().network),
+        addressToBech324(
+          orderInfo.order.datum.destination,
+          lucid.config().network
+        ),
         {
           kind: "inline",
           value: createDestinationDatum(
-            orderInfo.datum.destinationInlineDatum ?? null,
-            orderInfo.utxo
+            orderInfo.order.datum.destinationInlineDatum ?? null,
+            orderInfo.order.utxo
           )
         },
         addAssets18(
-          // Currently, we always take the max execution fee from the order utxo.
+          // 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.utxo.assets) - orderInfo.datum.maxExecutionFee
+            lovelacesAmt6(orderInfo.order.utxo.assets) - orderInfo.order.datum.maxExecutionFee
           ),
-          orderInfo.swapInfo.owedIasset > 0 ? mkAssetsOf16(iassetAc, orderInfo.swapInfo.owedIasset) : mkAssetsOf16(
+          orderInfo.orderType === "MINTING" ? mkAssetsOf16(iassetAc, orderInfo.swapInfo.owedIasset) : mkAssetsOf16(
             collateralAc,
             orderInfo.swapInfo.owedCollateralAsset
           )
@@ -11850,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,
@@ -11981,6 +12113,7 @@ export {
   encodePythMessage,
   encodeSignedPythMessage,
   endProposal,
+  estimateMinOrderOutputLovelaces,
   estimateUtxoMinLovelace,
   executeProposal,
   feedInterestOracle,
@@ -12133,7 +12266,9 @@ export {
   parseStakingRedeemer,
   parseStakingRedeemerOrThrow,
   partitionEpochToScaleToSums,
+  pickValidSatisfiableOrders,
   processSpRequest,
+  psmOrderType,
   randomRobsSubsetSatisfyingTargetCollateral,
   rationalAdd,
   rationalCeil,
@@ -12207,6 +12342,7 @@ export {
   startPriceOracleTx,
   submitTx,
   sum,
+  summariseOrder,
   summarizeActualLeverageRedemptions,
   toAssetClassFromLucid,
   toDataDerivedPythPrice,