@indigo-labs/indigo-sdk 0.3.9 → 0.3.10

package/dist/index.js

@@ -53,6 +53,7 @@ __export(index_exports, {
   InterestOracleDatumSchema: () => InterestOracleDatumSchema,
   InterestOracleParamsSchema: () => InterestOracleParamsSchema,
   MAX_E2S2S_ENTRIES_COUNT: () => MAX_E2S2S_ENTRIES_COUNT,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN: () => MAX_REDEMPTIONS_WITH_CDP_OPEN,
   MIN_ROB_COLLATERAL_AMT: () => MIN_ROB_COLLATERAL_AMT,
   ONE_DAY: () => ONE_DAY,
   ONE_HOUR: () => ONE_HOUR,
@@ -87,6 +88,7 @@ __export(index_exports, {
   adjustStakingPosition: () => adjustStakingPosition,
   alwaysFailValidator: () => alwaysFailValidator,
   annulRequest: () => annulRequest,
+  approximateLeverageRedemptions: () => approximateLeverageRedemptions,
   attachOracle: () => attachOracle,
   balance: () => balance,
   batchCollectInterest: () => batchCollectInterest,
@@ -97,8 +99,11 @@ __export(index_exports, {
   burnCdp: () => burnCdp,
   calculateAccruedInterest: () => calculateAccruedInterest,
   calculateAdaReward: () => calculateAdaReward,
+  calculateCollateralRatioFromLeverage: () => calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt: () => calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio: () => calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt: () => calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalCollateralForRedemption: () => calculateTotalCollateralForRedemption,
   calculateUnitaryInterest: () => calculateUnitaryInterest,
   calculateUnitaryInterestSinceOracleLastUpdated: () => calculateUnitaryInterestSinceOracleLastUpdated,
   cancelRob: () => cancelRob,
@@ -164,9 +169,9 @@ __export(index_exports, {
   getAssetClassComparisonStr: () => getAssetClassComparisonStr,
   getInlineDatumOrThrow: () => getInlineDatumOrThrow,
   getPythFeedConfig: () => getPythFeedConfig,
-  getRandomElement: () => getRandomElement,
   getUpdatedAccountDeposit: () => getUpdatedAccountDeposit,
   handleOracleForCollateralAsset: () => handleOracleForCollateralAsset,
+  iassetValueOfCollateral: () => iassetValueOfCollateral,
   init: () => init,
   initCDPCreator: () => initCDPCreator,
   initCollector: () => initCollector,
@@ -180,8 +185,10 @@ __export(index_exports, {
   initTreasury: () => initTreasury,
   initializeAsset: () => initializeAsset,
   insertSorted: () => insertSorted,
+  isBuyOrderFullyRedeemed: () => isBuyOrderFullyRedeemed,
   isFullyRedeemed: () => isFullyRedeemed,
   isSameEpochToScaleKey: () => isSameEpochToScaleKey,
+  leverageCdpWithRob: () => leverageCdpWithRob,
   liquidateCdp: () => liquidateCdp,
   liquidationHelper: () => liquidationHelper,
   loadSystemParamsFromFile: () => loadSystemParamsFromFile,
@@ -245,10 +252,6 @@ __export(index_exports, {
   parseIAssetDatumOrThrow: () => parseIAssetDatumOrThrow,
   parseInterestCollectionDatum: () => parseInterestCollectionDatum,
   parseInterestOracleDatum: () => parseInterestOracleDatum,
-  parsePollManager: () => parsePollManager,
-  parsePollManagerOrThrow: () => parsePollManagerOrThrow,
-  parsePollShard: () => parsePollShard,
-  parsePollShardOrThrow: () => parsePollShardOrThrow,
   parsePriceOracleDatum: () => parsePriceOracleDatum,
   parsePythStateDatum: () => parsePythStateDatum,
   parseRobDatum: () => parseRobDatum,
@@ -269,8 +272,8 @@ __export(index_exports, {
   parseStakingPosition: () => parseStakingPosition,
   parseStakingPositionOrThrow: () => parseStakingPositionOrThrow,
   partitionEpochToScaleToSums: () => partitionEpochToScaleToSums,
-  pollPassQuorum: () => pollPassQuorum,
   processSpRequest: () => processSpRequest,
+  randomRobsSubsetSatisfyingTargetCollateral: () => randomRobsSubsetSatisfyingTargetCollateral,
   rationalAdd: () => rationalAdd,
   rationalCeil: () => rationalCeil,
   rationalDiv: () => rationalDiv,
@@ -289,7 +292,10 @@ __export(index_exports, {
   requestSpAccountClosure: () => requestSpAccountClosure,
   requestSpAccountCreation: () => requestSpAccountCreation,
   rewardSnapshotPrecision: () => rewardSnapshotPrecision,
-  robAmountToSpend: () => robAmountToSpend,
+  robAmtToSpend: () => robAmtToSpend,
+  robBuyOrderSummary: () => robBuyOrderSummary,
+  robCollateralAmtToSpend: () => robCollateralAmtToSpend,
+  robIAssetAmtToSpend: () => robIAssetAmtToSpend,
   runCreateScriptRefTx: () => runCreateScriptRefTx,
   runOneShotMintTx: () => runOneShotMintTx,
   scriptRef: () => scriptRef,
@@ -306,9 +312,6 @@ __export(index_exports, {
   serialiseInterestCollectionDatum: () => serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer: () => serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum: () => serialiseInterestOracleDatum,
-  serialisePollDatum: () => serialisePollDatum,
-  serialisePollManagerRedeemer: () => serialisePollManagerRedeemer,
-  serialisePollShardRedeemer: () => serialisePollShardRedeemer,
   serialisePriceOracleDatum: () => serialisePriceOracleDatum,
   serialisePriceOracleRedeemer: () => serialisePriceOracleRedeemer,
   serialisePythFeedParams: () => serialisePythFeedParams,
@@ -337,6 +340,7 @@ __export(index_exports, {
   startPriceOracleTx: () => startPriceOracleTx,
   submitTx: () => submitTx,
   sum: () => sum,
+  summarizeActualLeverageRedemptions: () => summarizeActualLeverageRedemptions,
   toAssetClassFromLucid: () => toAssetClassFromLucid,
   toDataDerivedPythPrice: () => toDataDerivedPythPrice,
   toSystemParamsAsset: () => toSystemParamsAsset,
@@ -723,7 +727,6 @@ function loadSystemParamsFromFile(file) {
 function loadSystemParamsFromUrl(url) {
   return fetch(url).then((res) => res.json()).then((data) => data);
 }
-var getRandomElement = (arr) => arr.length ? arr[Math.floor(Math.random() * arr.length)] : void 0;
 
 // src/utils/time-helpers.ts
 var ONE_SECOND = 1e3;
@@ -800,6 +803,11 @@ function calculateFeeFromRatio(feeRatio, amount) {
 
 // src/contracts/cdp/helpers.ts
 var import_cardano_offchain_common = require("@3rd-eye-labs/cardano-offchain-common");
+function iassetValueOfCollateral(collateralAmt, oraclePrice) {
+  return rationalFloor(
+    rationalDiv(rationalFromInt(collateralAmt), oraclePrice)
+  );
+}
 function cdpCollateralRatioPercentage(currentSlot, iassetPrice, cdpUtxo, cdpContent, interestOracleDatum, network) {
   const currentTime = BigInt((0, import_lucid4.slotToUnixTime)(network, currentSlot));
   return (0, import_ts_pattern5.match)(cdpContent.cdpFees).with({ ActiveCDPInterestTracking: import_ts_pattern5.P.select() }, (interest) => {
@@ -3909,6 +3917,7 @@ function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythS
   }).with(
     { DeferredValidation: { feedValHash: import_ts_pattern12.P.select() } },
     async (feedValHash) => {
+      if (priceOracleOref) throw new Error("Cannot pass price oracle oref");
       if (!pythMessage) throw new Error("Missing Pyth message");
       if (!pythStateOref) throw new Error("Missing pyth state out ref");
       const pythStateUtxo = matchSingle(
@@ -5371,185 +5380,25 @@ var mkPollShardValidatorFromSP = (params) => {
   };
 };
 
-// src/contracts/poll/types-poll-new.ts
-var import_evolution15 = require("@evolution-sdk/evolution");
-var import_cardano_offchain_common14 = require("@3rd-eye-labs/cardano-offchain-common");
-var import_fp_ts13 = require("fp-ts");
-var import_ts_pattern15 = require("ts-pattern");
-var PollStatusSchema = import_evolution15.TSchema.Struct({
-  yesVotes: import_evolution15.TSchema.Integer,
-  noVotes: import_evolution15.TSchema.Integer
-});
-var PollManagerContentSchema = import_evolution15.TSchema.Struct({
-  pollId: import_evolution15.TSchema.Integer,
-  pollOwner: import_evolution15.TSchema.ByteArray,
-  content: ProposalContentSchema,
-  treasuryWithdrawal: import_evolution15.TSchema.NullOr(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: import_evolution15.TSchema.Integer,
-  createdShardsCount: import_evolution15.TSchema.Integer,
-  talliedShardsCount: import_evolution15.TSchema.Integer,
-  totalShardsCount: import_evolution15.TSchema.Integer,
-  proposingEndTime: import_evolution15.TSchema.Integer,
-  expirationTime: import_evolution15.TSchema.Integer,
-  protocolVersion: import_evolution15.TSchema.Integer,
-  minimumQuorum: import_evolution15.TSchema.Integer
-});
-var PollShardContentSchema = import_evolution15.TSchema.Struct({
-  pollId: import_evolution15.TSchema.Integer,
-  status: PollStatusSchema,
-  votingEndTime: import_evolution15.TSchema.Integer,
-  managerAddress: import_cardano_offchain_common14.AddressSchema
-});
-var PollDatumSchema = import_evolution15.TSchema.Union(
-  import_evolution15.TSchema.Struct(
-    {
-      PollManager: PollManagerContentSchema
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution15.TSchema.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
-);
-var VoteOptionSchema = import_evolution15.TSchema.Union(
-  import_evolution15.TSchema.Literal("Yes", { flatInUnion: true }),
-  import_evolution15.TSchema.Literal("No", { flatInUnion: true })
-);
-var PollShardRedeemerSchema = import_evolution15.TSchema.Union(
-  import_evolution15.TSchema.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
-  import_evolution15.TSchema.Struct(
-    {
-      MergeShards: import_evolution15.TSchema.Struct(
-        {
-          currentTime: import_evolution15.TSchema.Integer,
-          pollManagerRef: import_cardano_offchain_common14.OutputReferenceSchema
-        },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-var PollManagerRedeemerSchema = import_evolution15.TSchema.Union(
-  import_evolution15.TSchema.Struct(
-    {
-      EndPoll: import_evolution15.TSchema.Struct(
-        { currentTime: import_evolution15.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution15.TSchema.Struct(
-    {
-      CreateShards: import_evolution15.TSchema.Struct(
-        { currentTime: import_evolution15.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  import_evolution15.TSchema.Struct(
-    {
-      MergeShardsManager: import_evolution15.TSchema.Struct(
-        { currentTime: import_evolution15.TSchema.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-function serialisePollManagerRedeemer(r) {
-  return import_evolution15.Data.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
-}
-function serialisePollShardRedeemer(r) {
-  return import_evolution15.Data.withSchema(PollShardRedeemerSchema).toCBORHex(r);
-}
-function parsePollManager(datum) {
-  try {
-    return (0, import_ts_pattern15.match)(
-      import_evolution15.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollManager: import_ts_pattern15.P.select() }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
-  } catch (_) {
-    return import_fp_ts13.option.none;
-  }
-}
-function parsePollManagerOrThrow(datum) {
-  return import_fp_ts13.function.pipe(
-    parsePollManager(datum),
-    import_fp_ts13.option.match(() => {
-      throw new Error("Expected a poll manager datum.");
-    }, import_fp_ts13.function.identity)
-  );
-}
-function parsePollShard(datum) {
-  try {
-    return (0, import_ts_pattern15.match)(
-      import_evolution15.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollShard: import_ts_pattern15.P.select() }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
-  } catch (_) {
-    return import_fp_ts13.option.none;
-  }
-}
-function parsePollShardOrThrow(datum) {
-  return import_fp_ts13.function.pipe(
-    parsePollShard(datum),
-    import_fp_ts13.option.match(() => {
-      throw new Error("Expected a poll shard datum.");
-    }, import_fp_ts13.function.identity)
-  );
-}
-function serialisePollDatum(d) {
-  return import_evolution15.Data.withSchema(PollDatumSchema).toCBORHex(d);
-}
-
-// src/contracts/poll/helpers.ts
-function q(pollStatus, e) {
-  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
-    return { getOnChainInt: 0n };
-  else {
-    const q2 = ocdDiv(
-      { getOnChainInt: pollStatus.yesVotes },
-      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
-    ).getOnChainInt - ocdDiv(
-      { getOnChainInt: pollStatus.noVotes },
-      {
-        getOnChainInt: BigInt(
-          Math.floor(
-            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
-          )
-        )
-      }
-    ).getOnChainInt;
-    return { getOnChainInt: BigInt(q2) };
-  }
-}
-function pollPassQuorum(pollStatus, electorate, minQuorum) {
-  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
-}
-
 // src/contracts/collector/transactions.ts
 var import_lucid22 = require("@lucid-evolution/lucid");
 
 // src/contracts/collector/types-new.ts
-var import_evolution16 = require("@evolution-sdk/evolution");
-var CollectorRedeemerSchema = import_evolution16.TSchema.Union(
-  import_evolution16.TSchema.Literal("Collect", { flatInUnion: true }),
-  import_evolution16.TSchema.Literal("DistributeToStakers", { flatInUnion: true }),
-  import_evolution16.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
+var import_evolution15 = require("@evolution-sdk/evolution");
+var CollectorRedeemerSchema = import_evolution15.TSchema.Union(
+  import_evolution15.TSchema.Literal("Collect", { flatInUnion: true }),
+  import_evolution15.TSchema.Literal("DistributeToStakers", { flatInUnion: true }),
+  import_evolution15.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseCollectorRedeemer(r) {
-  return import_evolution16.Data.withSchema(
+  return import_evolution15.Data.withSchema(
     CollectorRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 
 // src/contracts/collector/transactions.ts
-var import_cardano_offchain_common15 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_cardano_offchain_common14 = require("@3rd-eye-labs/cardano-offchain-common");
 async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   const collectorUtxo = matchSingle(
     await lucid.utxosByOutRef([collectorOref]),
@@ -5564,7 +5413,7 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
     { kind: "inline", value: import_lucid22.Data.void() },
-    (0, import_lucid22.addAssets)(collectorUtxo.assets, (0, import_cardano_offchain_common15.mkLovelacesOf)(fee))
+    (0, import_lucid22.addAssets)(collectorUtxo.assets, (0, import_cardano_offchain_common14.mkLovelacesOf)(fee))
   ).readFrom([collectorRefScriptUtxo]);
   return collectorRefScriptUtxo;
 }
@@ -5578,95 +5427,95 @@ var import_fp_ts15 = require("fp-ts");
 var import_ts_pattern17 = require("ts-pattern");
 
 // src/contracts/staking/types-new.ts
-var import_evolution17 = require("@evolution-sdk/evolution");
-var import_fp_ts14 = require("fp-ts");
-var import_ts_pattern16 = require("ts-pattern");
-var StakingPosLockedAmtSchema = import_evolution17.TSchema.Array(
-  import_evolution17.TSchema.Tuple([
-    import_evolution17.TSchema.Integer,
-    import_evolution17.TSchema.Struct({
-      voteAmt: import_evolution17.TSchema.Integer,
-      votingEnd: import_evolution17.TSchema.Integer
+var import_evolution16 = require("@evolution-sdk/evolution");
+var import_fp_ts13 = require("fp-ts");
+var import_ts_pattern15 = require("ts-pattern");
+var StakingPosLockedAmtSchema = import_evolution16.TSchema.Array(
+  import_evolution16.TSchema.Tuple([
+    import_evolution16.TSchema.Integer,
+    import_evolution16.TSchema.Struct({
+      voteAmt: import_evolution16.TSchema.Integer,
+      votingEnd: import_evolution16.TSchema.Integer
     })
   ])
 );
-var RewardSnapshotSchema = import_evolution17.TSchema.Struct({
-  snapshotAda: import_evolution17.TSchema.Integer
+var RewardSnapshotSchema = import_evolution16.TSchema.Struct({
+  snapshotAda: import_evolution16.TSchema.Integer
 });
-var StakingPositionSchema = import_evolution17.TSchema.Struct({
-  owner: import_evolution17.TSchema.ByteArray,
+var StakingPositionSchema = import_evolution16.TSchema.Struct({
+  owner: import_evolution16.TSchema.ByteArray,
   lockedAmount: StakingPosLockedAmtSchema,
   positionSnapshot: RewardSnapshotSchema
 });
-var StakingManagerSchema = import_evolution17.TSchema.Struct({
-  totalStake: import_evolution17.TSchema.Integer,
+var StakingManagerSchema = import_evolution16.TSchema.Struct({
+  totalStake: import_evolution16.TSchema.Integer,
   managerSnapshot: RewardSnapshotSchema
 });
-var StakingDatumSchema = import_evolution17.TSchema.Union(
+var StakingDatumSchema = import_evolution16.TSchema.Union(
   StakingManagerSchema,
   StakingPositionSchema
 );
-var StakingRedeemerSchema = import_evolution17.TSchema.Union(
-  import_evolution17.TSchema.Struct(
+var StakingRedeemerSchema = import_evolution16.TSchema.Union(
+  import_evolution16.TSchema.Struct(
     {
-      CreateStakingPosition: import_evolution17.TSchema.Struct(
-        { creatorPkh: import_evolution17.TSchema.ByteArray },
+      CreateStakingPosition: import_evolution16.TSchema.Struct(
+        { creatorPkh: import_evolution16.TSchema.ByteArray },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  import_evolution17.TSchema.Literal("UpdateTotalStake", { flatInUnion: true }),
-  import_evolution17.TSchema.Literal("Distribute", { flatInUnion: true }),
-  import_evolution17.TSchema.Struct(
+  import_evolution16.TSchema.Literal("UpdateTotalStake", { flatInUnion: true }),
+  import_evolution16.TSchema.Literal("Distribute", { flatInUnion: true }),
+  import_evolution16.TSchema.Struct(
     {
-      AdjustStakedAmount: import_evolution17.TSchema.Struct(
-        { adjustAmount: import_evolution17.TSchema.Integer },
+      AdjustStakedAmount: import_evolution16.TSchema.Struct(
+        { adjustAmount: import_evolution16.TSchema.Integer },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  import_evolution17.TSchema.Literal("Unstake", { flatInUnion: true }),
-  import_evolution17.TSchema.Literal("Lock", { flatInUnion: true }),
-  import_evolution17.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
+  import_evolution16.TSchema.Literal("Unstake", { flatInUnion: true }),
+  import_evolution16.TSchema.Literal("Lock", { flatInUnion: true }),
+  import_evolution16.TSchema.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseStakingRedeemer(r) {
-  return import_evolution17.Data.withSchema(
+  return import_evolution16.Data.withSchema(
     StakingRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 function parseStakingPosition(datum) {
   try {
-    return (0, import_ts_pattern16.match)(
-      import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+    return (0, import_ts_pattern15.match)(
+      import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
         datum
       )
-    ).with({ owner: import_ts_pattern16.P.any }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
+    ).with({ owner: import_ts_pattern15.P.any }, (res) => import_fp_ts13.option.some(res)).otherwise(() => import_fp_ts13.option.none);
   } catch (_) {
-    return import_fp_ts14.option.none;
+    return import_fp_ts13.option.none;
   }
 }
 function parseStakingPositionOrThrow(datum) {
-  return import_fp_ts14.function.pipe(
+  return import_fp_ts13.function.pipe(
     parseStakingPosition(datum),
-    import_fp_ts14.option.match(() => {
+    import_fp_ts13.option.match(() => {
       throw new Error("Expected a StakingPosition datum.");
-    }, import_fp_ts14.function.identity)
+    }, import_fp_ts13.function.identity)
   );
 }
 function parseStakingManagerDatum(datum) {
-  return (0, import_ts_pattern16.match)(
-    import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+  return (0, import_ts_pattern15.match)(
+    import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
       datum
     )
-  ).with({ totalStake: import_ts_pattern16.P.any }, (res) => res).otherwise(() => {
+  ).with({ totalStake: import_ts_pattern15.P.any }, (res) => res).otherwise(() => {
     throw new Error("Expected a StakingPosition datum.");
   });
 }
 function serialiseStakingDatum(d) {
-  return import_evolution17.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+  return import_evolution16.Data.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
     d
   );
 }
@@ -5781,22 +5630,182 @@ function calculateAdaReward(currentSnapshotAda, oldSnapshotAda, existingIndyAmou
   return (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / rewardSnapshotPrecision;
 }
 
+// src/contracts/poll/helpers.ts
+function q(pollStatus, e) {
+  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
+    return { getOnChainInt: 0n };
+  else {
+    const q2 = ocdDiv(
+      { getOnChainInt: pollStatus.yesVotes },
+      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
+    ).getOnChainInt - ocdDiv(
+      { getOnChainInt: pollStatus.noVotes },
+      {
+        getOnChainInt: BigInt(
+          Math.floor(
+            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
+          )
+        )
+      }
+    ).getOnChainInt;
+    return { getOnChainInt: BigInt(q2) };
+  }
+}
+function pollPassQuorum(pollStatus, electorate, minQuorum) {
+  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
+}
+
 // src/contracts/version-registry/types-new.ts
-var import_evolution18 = require("@evolution-sdk/evolution");
-var VersionRecordDatumSchema = import_evolution18.TSchema.Struct({
-  upgradeId: import_evolution18.TSchema.Integer,
+var import_evolution17 = require("@evolution-sdk/evolution");
+var VersionRecordDatumSchema = import_evolution17.TSchema.Struct({
+  upgradeId: import_evolution17.TSchema.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: import_evolution18.TSchema.Array(
-    import_evolution18.TSchema.Tuple([import_evolution18.TSchema.ByteArray, import_evolution18.TSchema.ByteArray])
+  upgradePaths: import_evolution17.TSchema.Array(
+    import_evolution17.TSchema.Tuple([import_evolution17.TSchema.ByteArray, import_evolution17.TSchema.ByteArray])
   )
 });
 function serialiseVersionRecordDatum(d) {
-  return import_evolution18.Data.withSchema(
+  return import_evolution17.Data.withSchema(
     VersionRecordDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
 }
 
+// src/contracts/poll/types-poll-new.ts
+var import_evolution18 = require("@evolution-sdk/evolution");
+var import_cardano_offchain_common15 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_fp_ts14 = require("fp-ts");
+var import_ts_pattern16 = require("ts-pattern");
+var PollStatusSchema = import_evolution18.TSchema.Struct({
+  yesVotes: import_evolution18.TSchema.Integer,
+  noVotes: import_evolution18.TSchema.Integer
+});
+var PollManagerContentSchema = import_evolution18.TSchema.Struct({
+  pollId: import_evolution18.TSchema.Integer,
+  pollOwner: import_evolution18.TSchema.ByteArray,
+  content: ProposalContentSchema,
+  treasuryWithdrawal: import_evolution18.TSchema.NullOr(TreasuryWithdrawalSchema),
+  status: PollStatusSchema,
+  votingEndTime: import_evolution18.TSchema.Integer,
+  createdShardsCount: import_evolution18.TSchema.Integer,
+  talliedShardsCount: import_evolution18.TSchema.Integer,
+  totalShardsCount: import_evolution18.TSchema.Integer,
+  proposingEndTime: import_evolution18.TSchema.Integer,
+  expirationTime: import_evolution18.TSchema.Integer,
+  protocolVersion: import_evolution18.TSchema.Integer,
+  minimumQuorum: import_evolution18.TSchema.Integer
+});
+var PollShardContentSchema = import_evolution18.TSchema.Struct({
+  pollId: import_evolution18.TSchema.Integer,
+  status: PollStatusSchema,
+  votingEndTime: import_evolution18.TSchema.Integer,
+  managerAddress: import_cardano_offchain_common15.AddressSchema
+});
+var PollDatumSchema = import_evolution18.TSchema.Union(
+  import_evolution18.TSchema.Struct(
+    {
+      PollManager: PollManagerContentSchema
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution18.TSchema.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
+);
+var VoteOptionSchema = import_evolution18.TSchema.Union(
+  import_evolution18.TSchema.Literal("Yes", { flatInUnion: true }),
+  import_evolution18.TSchema.Literal("No", { flatInUnion: true })
+);
+var PollShardRedeemerSchema = import_evolution18.TSchema.Union(
+  import_evolution18.TSchema.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
+  import_evolution18.TSchema.Struct(
+    {
+      MergeShards: import_evolution18.TSchema.Struct(
+        {
+          currentTime: import_evolution18.TSchema.Integer,
+          pollManagerRef: import_cardano_offchain_common15.OutputReferenceSchema
+        },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+var PollManagerRedeemerSchema = import_evolution18.TSchema.Union(
+  import_evolution18.TSchema.Struct(
+    {
+      EndPoll: import_evolution18.TSchema.Struct(
+        { currentTime: import_evolution18.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution18.TSchema.Struct(
+    {
+      CreateShards: import_evolution18.TSchema.Struct(
+        { currentTime: import_evolution18.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  import_evolution18.TSchema.Struct(
+    {
+      MergeShardsManager: import_evolution18.TSchema.Struct(
+        { currentTime: import_evolution18.TSchema.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+function serialisePollManagerRedeemer(r) {
+  return import_evolution18.Data.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
+}
+function serialisePollShardRedeemer(r) {
+  return import_evolution18.Data.withSchema(PollShardRedeemerSchema).toCBORHex(r);
+}
+function parsePollManager(datum) {
+  try {
+    return (0, import_ts_pattern16.match)(
+      import_evolution18.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollManager: import_ts_pattern16.P.select() }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
+  } catch (_) {
+    return import_fp_ts14.option.none;
+  }
+}
+function parsePollManagerOrThrow(datum) {
+  return import_fp_ts14.function.pipe(
+    parsePollManager(datum),
+    import_fp_ts14.option.match(() => {
+      throw new Error("Expected a poll manager datum.");
+    }, import_fp_ts14.function.identity)
+  );
+}
+function parsePollShard(datum) {
+  try {
+    return (0, import_ts_pattern16.match)(
+      import_evolution18.Data.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollShard: import_ts_pattern16.P.select() }, (res) => import_fp_ts14.option.some(res)).otherwise(() => import_fp_ts14.option.none);
+  } catch (_) {
+    return import_fp_ts14.option.none;
+  }
+}
+function parsePollShardOrThrow(datum) {
+  return import_fp_ts14.function.pipe(
+    parsePollShard(datum),
+    import_fp_ts14.option.match(() => {
+      throw new Error("Expected a poll shard datum.");
+    }, import_fp_ts14.function.identity)
+  );
+}
+function serialisePollDatum(d) {
+  return import_evolution18.Data.withSchema(PollDatumSchema).toCBORHex(d);
+}
+
 // src/contracts/gov/transactions.ts
 var import_cardano_offchain_common17 = require("@3rd-eye-labs/cardano-offchain-common");
 async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
@@ -5914,9 +5923,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
           )
         )
       )
-    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(
-      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
-    ).addSigner(ownAddr),
+    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).addSigner(ownAddr),
     newPollId
   ];
 }
@@ -5958,7 +5965,7 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
   );
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   const tx = lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).mintAssets((0, import_cardano_offchain_common16.mkAssetsOf)(pollNft, shardsCount), import_lucid26.Data.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({ CreateShards: { currentTime } })
@@ -6138,7 +6145,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
   )(shardUtxos);
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   return lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).readFrom([
     pollShardRefScriptUtxo,
     pollManagerRefScriptUtxo,
@@ -6925,9 +6932,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     );
   }).otherwise(() => {
   });
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
-  ).collectFrom([executeUtxo], import_lucid26.Data.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], import_lucid26.Data.void()).mintAssets(
     (0, import_cardano_offchain_common16.mkAssetsOf)(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
     import_lucid26.Data.void()
   ).addSigner(ownAddr).setMinFee(922932n);
@@ -8448,7 +8453,7 @@ var import_fp_ts17 = require("fp-ts");
 var import_ts_pattern19 = require("ts-pattern");
 var import_cardano_offchain_common22 = require("@3rd-eye-labs/cardano-offchain-common");
 var MIN_ROB_COLLATERAL_AMT = 3000000n;
-function robAmountToSpend(utxo, datum, sysParams) {
+function robCollateralAmtToSpend(utxo, datum) {
   return (0, import_ts_pattern19.match)(datum.orderType).returnType().with({ BuyIAssetOrder: import_ts_pattern19.P.select() }, (content) => {
     if ((0, import_cardano_offchain_common22.isSameAssetClass)(import_cardano_offchain_common22.adaAssetClass, content.collateralAsset)) {
       return zeroNegatives(
@@ -8457,24 +8462,61 @@ function robAmountToSpend(utxo, datum, sysParams) {
     } else {
       return (0, import_cardano_offchain_common22.assetClassValueOf)(utxo.assets, content.collateralAsset);
     }
-  }).with({ SellIAssetOrder: import_ts_pattern19.P.any }, (_) => {
+  }).otherwise(() => {
+    throw new Error("Collateral to spend is relevant only for Buy orders.");
+  });
+}
+function robIAssetAmtToSpend(utxo, datum, iassetCurrencySymbol) {
+  return (0, import_ts_pattern19.match)(datum.orderType).returnType().with({ SellIAssetOrder: import_ts_pattern19.P.any }, (_) => {
     return (0, import_cardano_offchain_common22.assetClassValueOf)(utxo.assets, {
-      currencySymbol: (0, import_lucid49.fromHex)(
-        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol
-      ),
+      currencySymbol: (0, import_lucid49.fromHex)(iassetCurrencySymbol.unCurrencySymbol),
       tokenName: datum.iasset
     });
-  }).exhaustive();
+  }).otherwise(() => {
+    throw new Error("IAssets to spend is relevant only for Sell orders.");
+  });
+}
+function robAmtToSpend(utxo, datum, iassetCurrencySymbol) {
+  return (0, import_ts_pattern19.match)(datum.orderType).with({ BuyIAssetOrder: import_ts_pattern19.P.any }, () => robCollateralAmtToSpend(utxo, datum)).with(
+    { SellIAssetOrder: import_ts_pattern19.P.any },
+    () => robIAssetAmtToSpend(utxo, datum, iassetCurrencySymbol)
+  ).exhaustive();
 }
-function isFullyRedeemed(utxo, datum, sysParams) {
-  return robAmountToSpend(utxo, datum, sysParams) === 0n;
+function robBuyOrderSummary(utxo, datum, oraclePrice) {
+  const redeemable = robCollateralAmtToSpend(utxo, datum);
+  const payoutAmt = iassetValueOfCollateral(redeemable, oraclePrice);
+  return {
+    redeemableCollateral: redeemable,
+    payoutIAsset: payoutAmt
+  };
+}
+function isBuyOrderFullyRedeemed(utxo, datum, oraclePrice) {
+  const summary = robBuyOrderSummary(utxo, datum, oraclePrice);
+  return summary.redeemableCollateral <= 0n || summary.payoutIAsset <= 0n;
+}
+function isFullyRedeemed(utxo, datum, iassetCurrencySymbol) {
+  return (0, import_ts_pattern19.match)(datum.orderType).returnType().with(
+    { BuyIAssetOrder: import_ts_pattern19.P.select() },
+    (content) => isBuyOrderFullyRedeemed(utxo, datum, content.maxPrice)
+  ).with({ SellIAssetOrder: import_ts_pattern19.P.select() }, (content) => {
+    const iassetToSpend = robIAssetAmtToSpend(
+      utxo,
+      datum,
+      iassetCurrencySymbol
+    );
+    const payoutAmts = content.allowedCollateralAssets.map(
+      (c) => rationalFloor(rationalMul(rationalFromInt(iassetToSpend), c[1]))
+    );
+    return iassetToSpend <= 0n || // When for every allowed collateral asset the payout would be 0
+    payoutAmts.every((amt) => amt <= 0n);
+  }).exhaustive();
 }
 function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redemptionReimbursementRatio, sysParams, tx, txOutputsBeforeCount, collateralAssetRefInputIdx, iassetRefInputIdx, oracleIdx) {
   return import_fp_ts17.function.pipe(
     redemptions,
     import_fp_ts17.array.reduceWithIndex(
       tx,
-      (idx, acc, [robUtxo, spendAmt]) => {
+      (idx, acc, [robUtxo, payoutAmt]) => {
         const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
         if ((0, import_lucid49.toHex)(robDatum.iasset) !== (0, import_lucid49.toHex)(iasset)) {
           throw new Error("Only same iAsset");
@@ -8485,7 +8527,7 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
           if (!(0, import_cardano_offchain_common22.isSameAssetClass)(content.collateralAsset, collateralAsset)) {
             throw new Error("Only same collateral asset");
           }
-          const payoutIAssetAmt = spendAmt;
+          const payoutIAssetAmt = payoutAmt;
           const reimburstmentIAsset = calculateFeeFromRatio(
             redemptionReimbursementRatio,
             payoutIAssetAmt
@@ -8520,16 +8562,14 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
               throw new Error("Doesn't allow required collateral asset.");
             })
           );
-          const payoutCollateralAmt = spendAmt;
+          const payoutCollateralAmt = payoutAmt;
           const reimbursementCollateral = calculateFeeFromRatio(
             redemptionReimbursementRatio,
             payoutCollateralAmt
           );
-          const redeemedIAssetAmt = rationalFloor(
-            rationalDiv(
-              rationalFromInt(payoutCollateralAmt - reimbursementCollateral),
-              price
-            )
+          const redeemedIAssetAmt = iassetValueOfCollateral(
+            payoutCollateralAmt - reimbursementCollateral,
+            price
           );
           const resultVal = (0, import_lucid49.addAssets)(
             robUtxo.assets,
@@ -8547,7 +8587,9 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
           return [resultVal, BigInt(allowedAssetIdx)];
         }).exhaustive();
         if ((0, import_cardano_offchain_common22.lovelacesAmt)(robOutputVal) < MIN_ROB_COLLATERAL_AMT) {
-          throw new Error("ROB was incorrectly initialised.");
+          throw new Error(
+            "Redeeming more than available or selected ROB was incorrectly initialised."
+          );
         }
         return acc.collectFrom([robUtxo], {
           kind: "self",
@@ -8558,7 +8600,7 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
               iassetRefInputIdx,
               continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
               sellOrderAllowedAssetsIdx,
-              priceOracleIdx: oracleIdx != null ? { OracleRefInputIdx: oracleIdx } : "OracleVoid"
+              priceOracleIdx: oracleIdx
             }
           })
         }).pay.ToContract(
@@ -8579,6 +8621,85 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
     )
   );
 }
+function calculateTotalCollateralForRedemption(iasset, collateralAsset, iassetPrice, allRobs, maxRobsInTx) {
+  return import_fp_ts17.function.pipe(
+    allRobs,
+    import_fp_ts17.array.filterMap(([utxo, datum]) => {
+      const isCorrectOrder = (0, import_ts_pattern19.match)(datum.orderType).returnType().with(
+        { BuyIAssetOrder: import_ts_pattern19.P.select() },
+        (content) => (0, import_cardano_offchain_common22.isSameAssetClass)(content.collateralAsset, collateralAsset) && rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice) && !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice)
+      ).otherwise(() => false);
+      if ((0, import_lucid49.toHex)(datum.iasset) !== (0, import_lucid49.toHex)(iasset) || !isCorrectOrder) {
+        return import_fp_ts17.option.none;
+      }
+      const collateralToSpend = robCollateralAmtToSpend(utxo, datum);
+      return import_fp_ts17.option.some(collateralToSpend);
+    }),
+    // From largest to smallest
+    import_fp_ts17.array.sort(import_fp_ts17.ord.reverse(BigIntOrd)),
+    // We can fit only this number of redemptions with CDP open into a single Tx.
+    import_fp_ts17.array.takeLeft(maxRobsInTx),
+    sum
+  );
+}
+function randomRobsSubsetSatisfyingTargetCollateral(iasset, collateralAsset, targetCollateralToSpend, iassetPrice, allLrps, maxLrpsInTx, randomiseFn = shuffle) {
+  if (targetCollateralToSpend <= 0n || iassetValueOfCollateral(targetCollateralToSpend, iassetPrice) <= 0n) {
+    throw new Error("Must redeem and payout more than 0.");
+  }
+  const shuffled = randomiseFn(
+    import_fp_ts17.function.pipe(
+      allLrps,
+      import_fp_ts17.array.filter(
+        ([utxo, datum]) => (0, import_lucid49.toHex)(datum.iasset) === (0, import_lucid49.toHex)(iasset) && (0, import_ts_pattern19.match)(datum.orderType).with(
+          { BuyIAssetOrder: import_ts_pattern19.P.select() },
+          (content) => (0, import_cardano_offchain_common22.isSameAssetClass)(collateralAsset, content.collateralAsset) && rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice)
+        ).otherwise(() => false) && !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice)
+      )
+    )
+  );
+  let result = [];
+  let runningSum = 0n;
+  for (let i = 0; i < shuffled.length; i++) {
+    const element = shuffled[i];
+    const lovelacesToSpend = robCollateralAmtToSpend(element[0], element[1]);
+    const remainingToRedeem = targetCollateralToSpend - runningSum;
+    const remainingToPayout = iassetValueOfCollateral(
+      remainingToRedeem,
+      iassetPrice
+    );
+    if (result.length > 0 && remainingToPayout <= 0n) {
+      const last = result[result.length - 1];
+      const lastSummary = robBuyOrderSummary(last[0], last[1], iassetPrice);
+      if (lastSummary.redeemableCollateral < lovelacesToSpend) {
+        result.pop();
+        runningSum -= lastSummary.redeemableCollateral;
+      } else {
+        continue;
+      }
+    }
+    result = insertSorted(
+      result,
+      element,
+      import_fp_ts17.ord.contramap(
+        ([utxo, dat]) => robCollateralAmtToSpend(utxo, dat)
+        // From highest to lowest
+      )(import_fp_ts17.ord.reverse(BigIntOrd))
+    );
+    runningSum += lovelacesToSpend;
+    if (result.length > maxLrpsInTx) {
+      const popped = result.pop();
+      runningSum -= robCollateralAmtToSpend(popped[0], popped[1]);
+    }
+    if (runningSum >= targetCollateralToSpend) {
+      return result;
+    }
+  }
+  const remainingToSpend = targetCollateralToSpend - runningSum;
+  if (remainingToSpend > 0n && iassetValueOfCollateral(remainingToSpend, iassetPrice) > 0n) {
+    throw new Error("Couldn't achieve target lovelaces");
+  }
+  return result;
+}
 
 // src/contracts/rob/types.ts
 var import_lucid50 = require("@lucid-evolution/lucid");
@@ -8718,7 +8839,7 @@ async function redeemRob(redemptionRobsData, priceOracleOutRef, iassetOutRef, co
     0n,
     refInputIdxs[2],
     refInputIdxs[1],
-    priceOracleOutRef !== void 0 ? refInputIdxs[3] : null
+    priceOracleOutRef !== void 0 ? { OracleRefInputIdx: refInputIdxs[3] } : "OracleVoid"
   );
   tx.readFrom(allRefInputs);
   return tx;
@@ -8735,12 +8856,12 @@ async function adjustRob(lucid, robOutRef, adjustmentAmt, newLimitPrice, sysPara
     (_) => new Error("Expected a single ROB UTXO.")
   );
   const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
-  if (adjustmentAmt === 0n && isFullyRedeemed(robUtxo, robDatum, sysParams)) {
+  if (adjustmentAmt === 0n && isFullyRedeemed(robUtxo, robDatum, sysParams.cdpParams.cdpAssetSymbol)) {
     throw new Error(
       "When there's no more lovelaces to spend, use close instead of claim."
     );
   }
-  if (adjustmentAmt < 0 && robAmountToSpend(robUtxo, robDatum, sysParams) <= -adjustmentAmt) {
+  if (adjustmentAmt < 0 && robAmtToSpend(robUtxo, robDatum, sysParams.cdpParams.cdpAssetSymbol) <= -adjustmentAmt) {
     throw new Error(
       "Can't adjust negatively by more than available. Also, for adjusting by exactly the amount deposited, a close action should be used instead."
     );
@@ -8861,11 +8982,443 @@ var mkRobValidatorFromSP = (params) => {
   };
 };
 
+// src/contracts/rob-leverage/transactions.ts
+var import_lucid53 = require("@lucid-evolution/lucid");
+
+// src/contracts/rob-leverage/helpers.ts
+var import_fp_ts19 = require("fp-ts");
+var import_decimal = require("decimal.js");
+var MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+function approximateLeverageRedemptions(baseCollateral, targetLeverage, redemptionReimbursementRatio, debtMintingFeeRatio) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal.Decimal)(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator
+  );
+  const redemptionReimbursementRatioDecimal = (0, import_decimal.Decimal)(
+    redemptionReimbursementRatio.numerator
+  ).div(redemptionReimbursementRatio.denominator);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const bExFees = (0, import_decimal.Decimal)(baseCollateral).mul(targetLeverage).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = {
+    numerator: fromDecimal((0, import_decimal.Decimal)(baseCollateral).add(bExFees)),
+    denominator: fromDecimal(b)
+  };
+  return {
+    leverage: targetLeverage,
+    collateralRatio,
+    redeemedCollateral: fromDecimal(bExFees)
+  };
+}
+function summarizeActualLeverageRedemptions(lovelacesForRedemptionWithReimbursement, redemptionReimbursementRatio, iassetPrice, redemptionLrps) {
+  const priceDecimal = (0, import_decimal.Decimal)(iassetPrice.numerator).div(
+    iassetPrice.denominator
+  );
+  const reimbRatio = (0, import_decimal.Decimal)(redemptionReimbursementRatio.numerator).div(
+    redemptionReimbursementRatio.denominator
+  );
+  const redemptionDetails = import_fp_ts19.function.pipe(
+    redemptionLrps,
+    import_fp_ts19.array.reduce(
+      {
+        remainingCollateralToSpend: lovelacesForRedemptionWithReimbursement,
+        redemptions: []
+      },
+      (acc, lrp) => {
+        if (acc.remainingCollateralToSpend <= 0n || iassetValueOfCollateral(
+          acc.remainingCollateralToSpend,
+          iassetPrice
+        ) <= 0n) {
+          return acc;
+        }
+        const collateralToSpend = robCollateralAmtToSpend(lrp[0], lrp[1]);
+        if (collateralToSpend === 0n) {
+          return acc;
+        }
+        const newRemainingCollateral = bigintMax(
+          acc.remainingCollateralToSpend - collateralToSpend,
+          0n
+        );
+        const collateralToSpendInitial = acc.remainingCollateralToSpend - newRemainingCollateral;
+        const finalPayoutIAssets = fromDecimal(
+          (0, import_decimal.Decimal)(collateralToSpendInitial).div(priceDecimal).floor().div((0, import_decimal.Decimal)(1).minus(reimbRatio)).floor()
+        );
+        const feeIAssetAmt = calculateFeeFromRatio(
+          redemptionReimbursementRatio,
+          finalPayoutIAssets
+        );
+        const finalCollateralToSpend = rationalFloor(
+          rationalMul(
+            rationalFromInt(finalPayoutIAssets - feeIAssetAmt),
+            iassetPrice
+          )
+        );
+        return {
+          remainingCollateralToSpend: acc.remainingCollateralToSpend - finalCollateralToSpend,
+          redemptions: [
+            ...acc.redemptions,
+            {
+              utxo: lrp[0],
+              iassetsPayoutAmt: finalPayoutIAssets,
+              redeemedCollateral: finalCollateralToSpend,
+              reimbursementIAssetAmt: feeIAssetAmt
+            }
+          ]
+        };
+      }
+    )
+  );
+  const res = import_fp_ts19.function.pipe(
+    redemptionDetails.redemptions,
+    import_fp_ts19.array.reduce(
+      {
+        redeemedCollateral: 0n,
+        payoutIAssets: 0n,
+        reimbursementIAssets: 0n
+      },
+      (acc, details) => {
+        return {
+          redeemedCollateral: acc.redeemedCollateral + details.redeemedCollateral,
+          reimbursementIAssets: acc.reimbursementIAssets + details.reimbursementIAssetAmt,
+          payoutIAssets: acc.payoutIAssets + details.iassetsPayoutAmt
+        };
+      }
+    )
+  );
+  return {
+    redemptions: redemptionDetails.redemptions,
+    totalRedeemedCollateral: res.redeemedCollateral,
+    totalReimbursedIAsset: res.reimbursementIAssets,
+    totalIAssetPayout: res.payoutIAssets
+  };
+}
+function calculateCollateralRatioFromLeverage(iasset, collateralAsset, leverage, baseCollateral, iassetPrice, debtMintingFeePercentage, redemptionReimbursementPercentage, allLrps) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal.Decimal)(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = (0, import_decimal.Decimal)(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const maxAvailableCollateralForRedemption = calculateTotalCollateralForRedemption(
+    iasset,
+    collateralAsset,
+    iassetPrice,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (leverage <= 1 || baseCollateral <= 0n || maxAvailableCollateralForRedemption <= 0n) {
+    return void 0;
+  }
+  const bExFees = (0, import_decimal.Decimal)(baseCollateral).mul(leverage).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b)
+  );
+  const cappedBExFees = (0, import_decimal.Decimal)(cappedB).mul((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = (0, import_decimal.Decimal)(
+    (0, import_decimal.Decimal)(baseCollateral).add(cappedBExFees)
+  ).div(cappedB);
+  return {
+    getOnChainInt: fromDecimal(
+      collateralRatio.mul(100n * OCD_DECIMAL_UNIT).floor()
+    )
+  };
+}
+function calculateLeverageFromCollateralRatio(iasset, collateralAsset, collateralRatio, baseCollateral, iassetPrice, debtMintingFeeRatio, redemptionReimbursementRatio, allLrps) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal.Decimal)(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator
+  );
+  const redemptionReimbursementRatioDecimal = (0, import_decimal.Decimal)(
+    redemptionReimbursementRatio.numerator
+  ).div(redemptionReimbursementRatio.denominator);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const collateralRatioDecimal = (0, import_decimal.Decimal)(collateralRatio.numerator).div(
+    collateralRatio.denominator
+  );
+  const maxAvailableCollateralForRedemption = calculateTotalCollateralForRedemption(
+    iasset,
+    collateralAsset,
+    iassetPrice,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (collateralRatioDecimal.toNumber() <= 1 || baseCollateral <= 0n || maxAvailableCollateralForRedemption <= 0n) {
+    return void 0;
+  }
+  const theoreticalMaxLeverage = (0, import_decimal.Decimal)((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).div(collateralRatioDecimal.minus(1).add(totalFeeRatio)).add(1);
+  const bExFees = theoreticalMaxLeverage.mul(baseCollateral).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b)
+  );
+  const cappedBExFees = (0, import_decimal.Decimal)(cappedB).mul((0, import_decimal.Decimal)(1).minus(totalFeeRatio)).floor();
+  return (0, import_decimal.Decimal)(baseCollateral).add(cappedBExFees).div(baseCollateral).toNumber();
+}
+
+// src/contracts/rob-leverage/transactions.ts
+var import_cardano_offchain_common24 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_decimal2 = __toESM(require("decimal.js"));
+async function leverageCdpWithRob(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, cdpCreatorOref, interestOracleOref, treasuryOref, sysParams, lucid, allRobs, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+  const network = lucid.config().network;
+  const currentTime = BigInt((0, import_lucid53.slotToUnixTime)(network, currentSlot));
+  const [pkh, skh] = await addrDetails(lucid);
+  const robScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef)
+    ]),
+    (_2) => new Error("Expected a single ROB Ref Script UTXO")
+  );
+  const cdpCreatorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.cdpCreatorValidatorRef
+      )
+    ]),
+    (_2) => new Error("Expected a single cdp creator Ref Script UTXO")
+  );
+  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef
+      )
+    ]),
+    (_2) => new Error("Expected a single cdp auth token policy Ref Script UTXO")
+  );
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.iAssetTokenPolicyRef
+      )
+    ]),
+    (_2) => new Error("Expected a single iasset token policy Ref Script UTXO")
+  );
+  const cdpCreatorUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpCreatorOref]),
+    (_2) => new Error("Expected a single CDP creator UTXO")
+  );
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_2) => new Error("Expected a single interest oracle UTXO")
+  );
+  const interestOracleDatum = parseInterestOracleDatum(
+    getInlineDatumOrThrow(interestOracleUtxo)
+  );
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOutRef]),
+    (_2) => new Error("Expected a single IAsset UTXO")
+  );
+  const iassetDatum = parseIAssetDatumOrThrow(
+    getInlineDatumOrThrow(iassetUtxo)
+  );
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOutRef]),
+    (_2) => new Error("Expected a single collateral asset UTXO")
+  );
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo)
+  );
+  const [price, _] = await retrieveAdjustedPrice(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    collateralAssetDatum.extraDecimals,
+    priceOracleOutRef,
+    pythMessage,
+    sysParams.pythConfig,
+    lucid
+  );
+  const maxLeverage = calculateLeverageFromCollateralRatio(
+    collateralAssetDatum.iasset,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.maintenanceRatio,
+    baseCollateral,
+    price,
+    iassetDatum.debtMintingFeeRatio,
+    iassetDatum.redemptionReimbursementRatio,
+    allRobs
+  );
+  if (!maxLeverage) {
+    throw new Error("Can't calculate max leverage with those parameters.");
+  }
+  const leverageSummary = approximateLeverageRedemptions(
+    baseCollateral,
+    leverage,
+    iassetDatum.redemptionProcessingFeeRatio,
+    iassetDatum.debtMintingFeeRatio
+  );
+  if (maxLeverage < leverageSummary.leverage) {
+    throw new Error("Can't use more leverage than max.");
+  }
+  if (rationalToFloat(leverageSummary.collateralRatio) < rationalToFloat(collateralAssetDatum.maintenanceRatio)) {
+    throw new Error(
+      "Can't have collateral ratio smaller than maintenance ratio"
+    );
+  }
+  const redemptionDetails = summarizeActualLeverageRedemptions(
+    leverageSummary.redeemedCollateral,
+    iassetDatum.redemptionReimbursementRatio,
+    price,
+    randomRobsSubsetSatisfyingTargetCollateral(
+      iassetDatum.assetName,
+      collateralAssetDatum.collateralAsset,
+      leverageSummary.redeemedCollateral,
+      price,
+      allRobs,
+      MAX_REDEMPTIONS_WITH_CDP_OPEN
+    )
+  );
+  const mintedAmt = fromDecimal(
+    (0, import_decimal2.default)(redemptionDetails.totalIAssetPayout).div(
+      (0, import_decimal2.default)(1).minus(
+        (0, import_decimal2.default)(iassetDatum.debtMintingFeeRatio.numerator).div(
+          iassetDatum.debtMintingFeeRatio.denominator
+        )
+      )
+    ).floor()
+  );
+  const debtMintingFee = calculateFeeFromRatio(
+    iassetDatum.debtMintingFeeRatio,
+    mintedAmt
+  );
+  const collateralAmt = redemptionDetails.totalRedeemedCollateral + baseCollateral;
+  const cdpNftVal = (0, import_cardano_offchain_common24.mkAssetsOf)(
+    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    1n
+  );
+  const iassetClass = {
+    currencySymbol: (0, import_lucid53.fromHex)(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol
+    ),
+    tokenName: iassetDatum.assetName
+  };
+  const iassetTokensVal = (0, import_cardano_offchain_common24.mkAssetsOf)(iassetClass, mintedAmt);
+  const refScripts = [
+    cdpCreatorRefScriptUtxo,
+    cdpAuthTokenPolicyRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+    robScriptRefUtxo
+  ];
+  const tx = lucid.newTx().readFrom(refScripts).mintAssets(cdpNftVal, import_lucid53.Data.void()).mintAssets(iassetTokensVal, import_lucid53.Data.void()).pay.ToContract(
+    createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
+    {
+      kind: "inline",
+      value: serialiseCdpDatum({
+        cdpOwner: (0, import_lucid53.fromHex)(pkh.hash),
+        iasset: iassetDatum.assetName,
+        collateralAsset: collateralAssetDatum.collateralAsset,
+        mintedAmt,
+        cdpFees: {
+          ActiveCDPInterestTracking: {
+            lastSettled: currentTime,
+            unitaryInterestSnapshot: calculateUnitaryInterestSinceOracleLastUpdated(
+              currentTime,
+              interestOracleDatum
+            ) + interestOracleDatum.unitaryInterest
+          }
+        }
+      })
+    },
+    (0, import_lucid53.addAssets)(
+      cdpNftVal,
+      (0, import_cardano_offchain_common24.mkAssetsOf)(collateralAssetDatum.collateralAsset, collateralAmt)
+    )
+  ).pay.ToContract(
+    cdpCreatorUtxo.address,
+    {
+      kind: "inline",
+      value: serialiseCDPCreatorDatum({
+        creatorInputOref: {
+          outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
+          txHash: (0, import_lucid53.fromHex)(cdpCreatorUtxo.txHash)
+        }
+      })
+    },
+    cdpCreatorUtxo.assets
+  );
+  const treasuryRefScriptUtxo = debtMintingFee > 0n ? await treasuryFeeTx(
+    iassetClass,
+    debtMintingFee,
+    0n,
+    lucid,
+    sysParams,
+    tx,
+    cdpCreatorUtxo,
+    treasuryOref
+  ) : void 0;
+  const { interval, referenceInputs: refInputs } = await attachOracle(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    priceOracleOutRef,
+    pythStateOref,
+    pythMessage,
+    sysParams.pythConfig,
+    sysParams.cdpCreatorParams.biasTime,
+    currentSlot,
+    lucid,
+    tx
+  );
+  const referenceInputs = [
+    interestOracleUtxo,
+    iassetUtxo,
+    collateralAssetUtxo,
+    ...refInputs
+  ];
+  const refInputsIndices = (0, import_lucid53.getInputIndices)(referenceInputs, [
+    ...referenceInputs,
+    ...refScripts,
+    ...treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []
+  ]);
+  const oracleIdx = priceOracleOutRef !== void 0 ? { OracleRefInputIdx: refInputsIndices[3] } : "OracleVoid";
+  tx.validFrom(interval.validFrom).validTo(interval.validTo).readFrom(referenceInputs).collectFrom([cdpCreatorUtxo], {
+    kind: "self",
+    makeRedeemer: (inputIdx) => {
+      return serialiseCDPCreatorRedeemer({
+        CreateCDP: {
+          cdpOwner: (0, import_lucid53.fromHex)(pkh.hash),
+          minted: mintedAmt,
+          collateralAmt,
+          currentTime,
+          creatorInputIdx: inputIdx,
+          creatorOutputIdx: 1n,
+          cdpOutputIdx: 0n,
+          iassetRefInputIdx: refInputsIndices[1],
+          collateralAssetRefInputIdx: refInputsIndices[2],
+          interestOracleRefInputIdx: refInputsIndices[0],
+          priceOracleIdx: oracleIdx
+        }
+      });
+    }
+  });
+  buildRedemptionsTx(
+    redemptionDetails.redemptions.map((r) => [r.utxo, r.iassetsPayoutAmt]),
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    price,
+    iassetDatum.redemptionReimbursementRatio,
+    sysParams,
+    tx,
+    2n + (debtMintingFee > 0n ? 1n : 0n),
+    refInputsIndices[2],
+    refInputsIndices[1],
+    oracleIdx
+  );
+  return tx;
+}
+
 // src/contracts/price-oracle/transactions.ts
-var import_lucid54 = require("@lucid-evolution/lucid");
+var import_lucid55 = require("@lucid-evolution/lucid");
 
 // src/contracts/price-oracle/scripts.ts
-var import_lucid53 = require("@lucid-evolution/lucid");
+var import_lucid54 = require("@lucid-evolution/lucid");
 
 // src/validators/price-oracle-validator.ts
 var _priceOracleValidator = {
@@ -8878,18 +9431,18 @@ var _priceOracleValidator = {
 function mkPriceOracleValidator(params) {
   return {
     type: "PlutusV3",
-    script: (0, import_lucid53.applyParamsToScript)(_priceOracleValidator.cborHex, [
+    script: (0, import_lucid54.applyParamsToScript)(_priceOracleValidator.cborHex, [
       castPriceOracleParams(params)
     ])
   };
 }
 
 // src/contracts/price-oracle/transactions.ts
-var import_cardano_offchain_common24 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_cardano_offchain_common25 = require("@3rd-eye-labs/cardano-offchain-common");
 var Core2 = __toESM(require("@evolution-sdk/evolution"));
 async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, currentSlot, refOutRef, auxiliaryData) {
   const network = lucid.config().network;
-  const now = BigInt((0, import_lucid54.slotToUnixTime)(network, currentSlot));
+  const now = BigInt((0, import_lucid55.slotToUnixTime)(network, currentSlot));
   if (!refOutRef) {
     refOutRef = (await lucid.wallet().getUtxos())[0];
   }
@@ -8900,31 +9453,31 @@ async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, cu
     },
     mintAmounts: [
       {
-        tokenName: (0, import_lucid54.fromText)(assetName),
+        tokenName: (0, import_lucid55.fromText)(assetName),
         amount: 1n
       }
     ]
   });
   const priceOracleNft = {
-    currencySymbol: (0, import_lucid54.fromHex)(oracleNftPolicyId),
-    tokenName: (0, import_lucid54.fromHex)((0, import_lucid54.fromText)(assetName))
+    currencySymbol: (0, import_lucid55.fromHex)(oracleNftPolicyId),
+    tokenName: (0, import_lucid55.fromHex)((0, import_lucid55.fromText)(assetName))
   };
   const oracleValidator = mkPriceOracleValidator(oracleParams);
   const oracleDatum = {
     price: startPrice,
     expirationTime: BigInt(now) + oracleParams.expirationPeriod,
-    auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(import_lucid54.Data.void())
+    auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(import_lucid55.Data.void())
   };
   tx.pay.ToContract(
-    (0, import_lucid54.validatorToAddress)(lucid.config().network, oracleValidator),
+    (0, import_lucid55.validatorToAddress)(lucid.config().network, oracleValidator),
     { kind: "inline", value: serialisePriceOracleDatum(oracleDatum) },
-    (0, import_lucid54.addAssets)((0, import_cardano_offchain_common24.mkAssetsOf)(priceOracleNft, 1n))
+    (0, import_lucid55.addAssets)((0, import_cardano_offchain_common25.mkAssetsOf)(priceOracleNft, 1n))
   );
   return [tx, priceOracleNft];
 }
 async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, currentSlot, auxiliaryData) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid54.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid55.slotToUnixTime)(network, currentSlot));
   const priceOracleUtxo = matchSingle(
     await lucid.utxosByOutRef([oracleOref]),
     (_) => new Error("Expected a single price oracle UTXO")
@@ -8943,7 +9496,7 @@ async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, curr
       value: serialisePriceOracleDatum({
         price: newPrice,
         expirationTime: currentTime + oracleParams.expirationPeriod,
-        auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(import_lucid54.Data.void())
+        auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(import_lucid55.Data.void())
       })
     },
     priceOracleUtxo.assets
@@ -8951,7 +9504,7 @@ async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, curr
 }
 
 // src/utils/helper-txs.ts
-var import_lucid55 = require("@lucid-evolution/lucid");
+var import_lucid56 = require("@lucid-evolution/lucid");
 
 // src/scripts/always-fail-validator.ts
 var alwaysFailValidator = {
@@ -8961,18 +9514,18 @@ var alwaysFailValidator = {
 
 // src/utils/helper-txs.ts
 async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
-  const scriptAddr = (0, import_lucid55.validatorToAddress)(network, alwaysFailValidator);
+  const scriptAddr = (0, import_lucid56.validatorToAddress)(network, alwaysFailValidator);
   const txHash = await lucid.newTx().pay.ToAddressWithData(scriptAddr, void 0, {}, scriptRefValidator).complete().then((tx) => tx.sign.withWallet().complete()).then((tx) => tx.submit());
   await lucid.awaitTx(txHash);
   return { txHash, outputIndex: 0 };
 }
 
 // src/contracts/initialize/helpers.ts
-var import_lucid59 = require("@lucid-evolution/lucid");
-var import_cardano_offchain_common25 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_lucid60 = require("@lucid-evolution/lucid");
+var import_cardano_offchain_common26 = require("@3rd-eye-labs/cardano-offchain-common");
 
 // src/scripts/auth-token-policy.ts
-var import_lucid56 = require("@lucid-evolution/lucid");
+var import_lucid57 = require("@lucid-evolution/lucid");
 var authPolicyData = {
   type: "PlutusV2",
   cborHex: "5904d95904d60100003232323232323232323232323232323232323232323232323232223232223232323253355335533357346042660166018a00200e03026464666ae68cdc419806980728019980b9999aa999ab9a3370e90030008990911118020029aba1302400215333573466e1d20040011321222230020053574260480042a666ae68c08c0044c848888c004014d5d098120010a999ab9a30220011321222230030053574260480040424c40024c4c016900100a80d98120009baa3500201d01813357389213d4d75737420636f6e73756d65204e4654206f7220746f6b656e2070726576696f75736c79206d696e746564207573696e67207468697320706f6c6963790001301415335738920103505435001613253335734604060460022646464646464646464646464646464646464646464642466666666666600202e02a02602201e01a01601200e00a0060046ae84d5d10011aba1001357440046ae84004d5d10011aba1001357440046ae84004d5d10011aba1001357440046ae84004d5d10011aba1001357440046ae84004d5d10011aba1001357440046ae84004d5d118118011aba1302200101f37546a002036a666ae68c078c0840084c8c848cc00400c008d5d09aba2302100335742604000403aa666ae68c074c080dd500180880e1baa00153335734603260380022646601e6ae84004d5d09aba2001301b00101837540044464646603a4466a0029000111a801112999ab9a3375e0040102660464466a0029000111a801112999ab9a3375e00401a20022600c0060022600c0060086a00402a6a0020264666aa6020026660144466aa601c02a46a002446601e00466aa602203046a0024466024004666a0026e012000700466e0000520000013355300e015235001223300f00233350012335530120192350012233013002300e0010012233300a0090020012335530120192350012233013002301000100133300500400200100e232333008200133008200175a6aa666ae68c05cc0680044c8c8c8c8c8c848cccc00401c01400c008d5d09aba2002357420026ae88008d5d08009aba2301a00235742603200202c44440066ea8d400404ccc06488cccd55cf800900891919809a999ab9a3019301c001132321233001003002357426ae88c070008d5d0980d80080c18021aba200337546ae84008054dd61a80091111111111100611199ab9a3375e00400201c010444666aa601602601e66aa601802646a002446601a0046010002666aa6016026446a00444a66a666aa602802e6601c4466601402e004002601002c46a002446601400400a00c200626602600800601c00266aa601802646a002446601a0046603844a66a002260180064426a00444a66a6601800401022444660040140082600c00600800446600244a66a004018200200a4244460060084446602c446666aae7c00480388c8cc040cc02cc01cc064004c018c060004c010d5d10019aba1002012375600242444600200820142014442466002006004601c4422444a66a00220044426600a004666aa600e01e00a008002601a442244a66a00200a44266012600800466aa600c01a00800220022006442446600200800660124422444a66a00226a00600e442666a00a0106008004666aa600e01400a0080024400444002240022a66ae71241035054310016370e90001b874800955cf2ab9d2323001001223300330020020011"
@@ -8980,15 +9533,15 @@ var authPolicyData = {
 function mkAuthTokenPolicy(ac, tn) {
   return {
     type: authPolicyData.type,
-    script: (0, import_lucid56.applyParamsToScript)(authPolicyData.cborHex, [
-      new import_lucid56.Constr(0, [(0, import_lucid56.toHex)(ac.currencySymbol), (0, import_lucid56.toHex)(ac.tokenName)]),
+    script: (0, import_lucid57.applyParamsToScript)(authPolicyData.cborHex, [
+      new import_lucid57.Constr(0, [(0, import_lucid57.toHex)(ac.currencySymbol), (0, import_lucid57.toHex)(ac.tokenName)]),
       tn
     ])
   };
 }
 
 // src/contracts/iasset/scripts.ts
-var import_lucid57 = require("@lucid-evolution/lucid");
+var import_lucid58 = require("@lucid-evolution/lucid");
 
 // src/validators/iasset-validator.ts
 var _iassetValidator = {
@@ -8998,8 +9551,8 @@ var _iassetValidator = {
 };
 
 // src/contracts/iasset/scripts.ts
-var import_lucid58 = require("@lucid-evolution/lucid");
-var IAssetScriptParamsSchema = import_lucid58.Data.Object({
+var import_lucid59 = require("@lucid-evolution/lucid");
+var IAssetScriptParamsSchema = import_lucid59.Data.Object({
   upgradeToken: AssetClassSchema2,
   versionRecordToken: AssetClassSchema2
 });
@@ -9007,8 +9560,8 @@ var IAssetScriptParams = IAssetScriptParamsSchema;
 var mkIAssetValidatorFromSP = (params) => {
   return {
     type: "PlutusV3",
-    script: (0, import_lucid57.applyParamsToScript)(_iassetValidator.cborHex, [
-      import_lucid58.Data.castTo(
+    script: (0, import_lucid58.applyParamsToScript)(_iassetValidator.cborHex, [
+      import_lucid59.Data.castTo(
         {
           upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
           versionRecordToken: fromSystemParamsAssetLucid(
@@ -9025,7 +9578,7 @@ var mkIAssetValidatorFromSP = (params) => {
 var import_ts_pattern21 = require("ts-pattern");
 
 // tests/test-helpers.ts
-var import_fp_ts19 = require("fp-ts");
+var import_fp_ts20 = require("fp-ts");
 async function runAndAwaitTxBuilder(lucid, transaction, extraSigners = []) {
   const bTx = await transaction.complete();
   const signatures = [await bTx.partialSign.withWallet()];
@@ -9086,22 +9639,22 @@ async function mintOneTimeToken(lucid, tokenName, amount) {
   });
 }
 async function mintOneTimeAsset(lucid, tokenName, amount) {
-  const policyId = await mintOneTimeToken(lucid, (0, import_lucid59.fromText)(tokenName), amount);
+  const policyId = await mintOneTimeToken(lucid, (0, import_lucid60.fromText)(tokenName), amount);
   return {
-    currencySymbol: (0, import_lucid59.fromHex)(policyId),
-    tokenName: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(tokenName))
+    currencySymbol: (0, import_lucid60.fromHex)(policyId),
+    tokenName: (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(tokenName))
   };
 }
 function deriveAuthToken(parent, tokenName) {
-  const policy = mkAuthTokenPolicy(parent, (0, import_lucid59.fromText)(tokenName));
+  const policy = mkAuthTokenPolicy(parent, (0, import_lucid60.fromText)(tokenName));
   return {
-    currencySymbol: (0, import_lucid59.fromHex)((0, import_lucid59.mintingPolicyToId)(policy)),
-    tokenName: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(tokenName))
+    currencySymbol: (0, import_lucid60.fromHex)((0, import_lucid60.mintingPolicyToId)(policy)),
+    tokenName: (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(tokenName))
   };
 }
 async function initScriptRef(lucid, validator) {
   const tx = lucid.newTx().pay.ToContract(
-    (0, import_lucid59.credentialToAddress)(lucid.config().network, {
+    (0, import_lucid60.credentialToAddress)(lucid.config().network, {
       hash: alwaysFailValidatorHash,
       type: "Script"
     }),
@@ -9119,11 +9672,11 @@ async function initCollector(lucid, collectorParams, numCollectors) {
     tx.pay.ToContract(
       createScriptAddress(
         lucid.config().network,
-        (0, import_lucid59.validatorToScriptHash)(mkCollectorValidatorFromSP(collectorParams))
+        (0, import_lucid60.validatorToScriptHash)(mkCollectorValidatorFromSP(collectorParams))
       ),
       {
         kind: "inline",
-        value: import_lucid59.Data.void()
+        value: import_lucid60.Data.void()
       }
     );
   }
@@ -9134,7 +9687,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
   const interestCollectionAdminDatum = {
     admin_permissions: {
       Signature: {
-        keyHash: (0, import_lucid59.fromHex)(pkh.hash)
+        keyHash: (0, import_lucid60.fromHex)(pkh.hash)
       }
     }
   };
@@ -9146,7 +9699,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
         kind: "inline",
         value: serialiseInterestCollectionDatum(interestCollectionAdminDatum)
       },
-      (0, import_cardano_offchain_common25.mkAssetsOf)(multisigUtxoNft, 1n)
+      (0, import_cardano_offchain_common26.mkAssetsOf)(multisigUtxoNft, 1n)
     )
   );
   const interestCollectionUtxoDeploymentTx = lucid.newTx();
@@ -9154,7 +9707,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
     interestCollectionUtxoDeploymentTx.pay.ToContract(
       createScriptAddress(lucid.config().network, interestCollectionValHash),
       void 0,
-      (0, import_cardano_offchain_common25.mkLovelacesOf)(interestCollectorUtxoLovelaces)
+      (0, import_cardano_offchain_common26.mkLovelacesOf)(interestCollectorUtxoLovelaces)
     );
   }
   await submitTx(lucid, interestCollectionUtxoDeploymentTx);
@@ -9163,15 +9716,15 @@ async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
   const tx = lucid.newTx();
   for (let i = 0; i < Number(numCdpCreators); i++) {
     tx.pay.ToContract(
-      (0, import_lucid59.credentialToAddress)(lucid.config().network, {
-        hash: (0, import_lucid59.validatorToScriptHash)(
+      (0, import_lucid60.credentialToAddress)(lucid.config().network, {
+        hash: (0, import_lucid60.validatorToScriptHash)(
           mkCDPCreatorValidatorFromSP(cdpCreatorParams)
         ),
         type: "Script"
       }),
-      { kind: "inline", value: import_lucid59.Data.void() },
+      { kind: "inline", value: import_lucid60.Data.void() },
       {
-        [cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol + (0, import_lucid59.fromText)(cdpCreatorParams.cdpCreatorNft[1].unTokenName)]: 1n
+        [cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol + (0, import_lucid60.fromText)(cdpCreatorParams.cdpCreatorNft[1].unTokenName)]: 1n
       }
     );
   }
@@ -9180,21 +9733,21 @@ async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
 async function initTreasury(lucid, treasuryParams, daoAsset, indyAsset, treasuryIndyAmount, numTreasuryCollectors) {
   const treasuryAddr = createScriptAddress(
     lucid.config().network,
-    (0, import_lucid59.validatorToScriptHash)(mkTreasuryValidatorFromSP(treasuryParams)),
+    (0, import_lucid60.validatorToScriptHash)(mkTreasuryValidatorFromSP(treasuryParams)),
     treasuryParams.treasuryUtxosStakeCredential != null ? fromSysParamsCredential(treasuryParams.treasuryUtxosStakeCredential) : void 0
   );
   const tx = lucid.newTx().pay.ToContract(
     treasuryAddr,
-    { kind: "inline", value: import_lucid59.Data.void() },
-    (0, import_lucid59.addAssets)(
-      (0, import_cardano_offchain_common25.mkAssetsOf)(daoAsset, 1n),
-      (0, import_cardano_offchain_common25.mkAssetsOf)(indyAsset, treasuryIndyAmount)
+    { kind: "inline", value: import_lucid60.Data.void() },
+    (0, import_lucid60.addAssets)(
+      (0, import_cardano_offchain_common26.mkAssetsOf)(daoAsset, 1n),
+      (0, import_cardano_offchain_common26.mkAssetsOf)(indyAsset, treasuryIndyAmount)
     )
   );
   for (let i = 0; i < Number(numTreasuryCollectors); i++) {
     tx.pay.ToContract(treasuryAddr, {
       kind: "inline",
-      value: import_lucid59.Data.void()
+      value: import_lucid60.Data.void()
     });
   }
   await submitTx(lucid, tx);
@@ -9203,7 +9756,7 @@ async function initStakingManager(lucid, stakingParams) {
   const tx = lucid.newTx().pay.ToContract(
     createScriptAddress(
       lucid.config().network,
-      (0, import_lucid59.validatorToScriptHash)(mkStakingValidatorFromSP(stakingParams))
+      (0, import_lucid60.validatorToScriptHash)(mkStakingValidatorFromSP(stakingParams))
     ),
     {
       kind: "inline",
@@ -9213,7 +9766,7 @@ async function initStakingManager(lucid, stakingParams) {
       })
     },
     {
-      [stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid59.fromText)(stakingParams.stakingManagerNFT[1].unTokenName)]: 1n
+      [stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid60.fromText)(stakingParams.stakingManagerNFT[1].unTokenName)]: 1n
     }
   );
   await submitTx(lucid, tx);
@@ -9239,10 +9792,10 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
     return Promise.resolve({
       info: {
         DeferredValidation: {
-          feedValHash: (0, import_lucid59.fromHex)(
+          feedValHash: (0, import_lucid60.fromHex)(
             getPythFeedConfig(
               pythConfig,
-              (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(iasset.name)),
+              (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(iasset.name)),
               collateralAsset.collateralAsset
             ).pythFeedValHash
           )
@@ -9253,7 +9806,7 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
   }).exhaustive();
 }
 async function initializeAsset(lucid, iassetParams, iassetToken, collateralAssetAuthToken, cdpAuthToken, cdpParams, stableswapValidatorHash, stabilityPoolParams, stabilityPoolToken, asset, pythConfig, currentSlot) {
-  const iassetName = (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(asset.name));
+  const iassetName = (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(asset.name));
   const collateralAssetInfos = [];
   for (const collateralAsset of asset.collateralAssets) {
     const [pkh, _] = await addrDetails(lucid);
@@ -9293,7 +9846,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     const collateralAssetTx = lucid.newTx().pay.ToContract(
       createScriptAddress(
         lucid.config().network,
-        (0, import_lucid59.validatorToScriptHash)(mkIAssetValidatorFromSP(iassetParams))
+        (0, import_lucid60.validatorToScriptHash)(mkIAssetValidatorFromSP(iassetParams))
       ),
       {
         kind: "inline",
@@ -9301,7 +9854,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
           CollateralAssetContent: collateralAssetContent
         })
       },
-      (0, import_cardano_offchain_common25.mkAssetsOf)(collateralAssetAuthToken, 1n)
+      (0, import_cardano_offchain_common26.mkAssetsOf)(collateralAssetAuthToken, 1n)
     );
     await submitTx(lucid, collateralAssetTx);
     collateralAssetInfos.push({
@@ -9319,24 +9872,24 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       redemptionFeeRatio: stableswapPool.redemptionFeeRatio,
       mintingEnabled: stableswapPool.mintingEnabled,
       redemptionEnabled: stableswapPool.redemptionEnabled,
-      feeManager: stableswapPool.feeManager ? (0, import_lucid59.fromHex)(stableswapPool.feeManager) : null,
+      feeManager: stableswapPool.feeManager ? (0, import_lucid60.fromHex)(stableswapPool.feeManager) : null,
       minMintOrderAmount: stableswapPool.minMintOrderAmount,
       minRedemptionOrderAmount: stableswapPool.minRedemptionOrderAmount,
       iasset: iassetName,
-      stableswapValHash: (0, import_lucid59.fromHex)(stableswapValidatorHash)
+      stableswapValHash: (0, import_lucid60.fromHex)(stableswapValidatorHash)
     };
     await submitTx(
       lucid,
       lucid.newTx().pay.ToContract(
         createScriptAddress(
           lucid.config().network,
-          (0, import_lucid59.validatorToScriptHash)(mkCdpValidatorFromSP(cdpParams))
+          (0, import_lucid60.validatorToScriptHash)(mkCdpValidatorFromSP(cdpParams))
         ),
         {
           kind: "inline",
           value: serialiseStableswapPoolDatum(stableswapPoolDatum)
         },
-        (0, import_cardano_offchain_common25.mkAssetsOf)(cdpAuthToken, 1n)
+        (0, import_cardano_offchain_common26.mkAssetsOf)(cdpAuthToken, 1n)
       )
     );
   }
@@ -9349,28 +9902,28 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     redemptionReimbursementRatio: asset.redemptionReimbursementRatio,
     redemptionProcessingFeeRatio: asset.redemptionProcessingFeeRatio,
     firstIAsset: asset.firstAsset,
-    nextIAsset: asset.nextAsset ? (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(asset.nextAsset)) : null
+    nextIAsset: asset.nextAsset ? (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(asset.nextAsset)) : null
   };
   const assetTx = lucid.newTx().pay.ToContract(
     createScriptAddress(
       lucid.config().network,
-      (0, import_lucid59.validatorToScriptHash)(mkIAssetValidatorFromSP(iassetParams))
+      (0, import_lucid60.validatorToScriptHash)(mkIAssetValidatorFromSP(iassetParams))
     ),
     {
       kind: "inline",
       value: serialiseIAssetDatum({ IAssetContent: iassetDatum })
     },
-    (0, import_cardano_offchain_common25.mkAssetsOf)(iassetToken, 1n)
+    (0, import_cardano_offchain_common26.mkAssetsOf)(iassetToken, 1n)
   );
   await submitTx(lucid, assetTx);
   const stabilityPoolDatum = {
-    iasset: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(asset.name)),
+    iasset: (0, import_lucid60.fromHex)((0, import_lucid60.fromText)(asset.name)),
     state: initSpState,
     assetStates: []
   };
   const spTx = lucid.newTx().pay.ToContract(
-    (0, import_lucid59.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid59.validatorToScriptHash)(
+    (0, import_lucid60.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid60.validatorToScriptHash)(
         mkStabilityPoolValidatorFromSP(stabilityPoolParams)
       ),
       type: "Script"
@@ -9379,7 +9932,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       kind: "inline",
       value: serialiseStabilityPoolDatum({ StabilityPool: stabilityPoolDatum })
     },
-    (0, import_cardano_offchain_common25.mkAssetsOf)(stabilityPoolToken, 1n)
+    (0, import_cardano_offchain_common26.mkAssetsOf)(stabilityPoolToken, 1n)
   );
   await submitTx(lucid, spTx);
   return {
@@ -9396,39 +9949,39 @@ async function initGovernance(lucid, governanceParams, govToken, initialAssets,
     iassetsCount: BigInt(initialAssets.length)
   };
   const tx = lucid.newTx().pay.ToContract(
-    (0, import_lucid59.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid59.validatorToScriptHash)(mkGovValidatorFromSP(governanceParams)),
+    (0, import_lucid60.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid60.validatorToScriptHash)(mkGovValidatorFromSP(governanceParams)),
       type: "Script"
     }),
     { kind: "inline", value: serialiseGovDatum(datum) },
-    (0, import_cardano_offchain_common25.mkAssetsOf)(govToken, 1n)
+    (0, import_cardano_offchain_common26.mkAssetsOf)(govToken, 1n)
   );
   await submitTx(lucid, tx);
 }
 async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
-  const script = mkAuthTokenPolicy(asset, (0, import_lucid59.fromText)(tokenName));
-  const policyId = (0, import_lucid59.mintingPolicyToId)(script);
+  const script = mkAuthTokenPolicy(asset, (0, import_lucid60.fromText)(tokenName));
+  const policyId = (0, import_lucid60.mintingPolicyToId)(script);
   const address = await lucid.wallet().address();
-  const utxos = (await lucid.utxosAtWithUnit(address, (0, import_cardano_offchain_common25.assetClassToUnit)(asset))).filter((utxo2) => (0, import_cardano_offchain_common25.assetClassValueOf)(utxo2.assets, asset) === 1n).sort((a, b) => Number((0, import_cardano_offchain_common25.lovelacesAmt)(b.assets) - (0, import_cardano_offchain_common25.lovelacesAmt)(a.assets)));
+  const utxos = (await lucid.utxosAtWithUnit(address, (0, import_cardano_offchain_common26.assetClassToUnit)(asset))).filter((utxo2) => (0, import_cardano_offchain_common26.assetClassValueOf)(utxo2.assets, asset) === 1n).sort((a, b) => Number((0, import_cardano_offchain_common26.lovelacesAmt)(b.assets) - (0, import_cardano_offchain_common26.lovelacesAmt)(a.assets)));
   if (utxos.length === 0) {
     throw new Error("No utxos found");
   }
   const utxo = utxos[0];
   const tx = lucid.newTx().attach.MintingPolicy(script).collectFrom([utxo]).mintAssets(
     {
-      [policyId + (0, import_lucid59.fromText)(tokenName)]: amount
+      [policyId + (0, import_lucid60.fromText)(tokenName)]: amount
     },
-    import_lucid59.Data.void()
+    import_lucid60.Data.void()
   );
   await submitTx(lucid, tx);
 }
 
 // src/contracts/initialize/actions.ts
-var import_lucid64 = require("@lucid-evolution/lucid");
-var import_cardano_offchain_common27 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_lucid65 = require("@lucid-evolution/lucid");
+var import_cardano_offchain_common28 = require("@3rd-eye-labs/cardano-offchain-common");
 
 // src/scripts/iasset-policy.ts
-var import_lucid60 = require("@lucid-evolution/lucid");
+var import_lucid61 = require("@lucid-evolution/lucid");
 var iassetPolicyData = {
   type: "PlutusV2",
   cborHex: "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"
@@ -9436,27 +9989,27 @@ var iassetPolicyData = {
 function mkIAssetTokenPolicy(ac) {
   return {
     type: iassetPolicyData.type,
-    script: (0, import_lucid60.applyParamsToScript)(iassetPolicyData.cborHex, [
-      new import_lucid60.Constr(0, [(0, import_lucid60.toHex)(ac.currencySymbol), (0, import_lucid60.toHex)(ac.tokenName)])
+    script: (0, import_lucid61.applyParamsToScript)(iassetPolicyData.cborHex, [
+      new import_lucid61.Constr(0, [(0, import_lucid61.toHex)(ac.currencySymbol), (0, import_lucid61.toHex)(ac.tokenName)])
     ])
   };
 }
 
 // src/contracts/stableswap/scripts.ts
-var import_lucid62 = require("@lucid-evolution/lucid");
+var import_lucid63 = require("@lucid-evolution/lucid");
 
 // src/contracts/stableswap/types.ts
-var import_lucid61 = require("@lucid-evolution/lucid");
-var StableswapParamsSchema = import_lucid61.Data.Object({
-  iassetSymbol: import_lucid61.Data.Bytes(),
+var import_lucid62 = require("@lucid-evolution/lucid");
+var StableswapParamsSchema = import_lucid62.Data.Object({
+  iassetSymbol: import_lucid62.Data.Bytes(),
   cdpToken: AssetClassSchema2,
   versionRecordToken: AssetClassSchema2,
-  cdpValHash: import_lucid61.Data.Bytes(),
-  treasuryValHash: import_lucid61.Data.Bytes()
+  cdpValHash: import_lucid62.Data.Bytes(),
+  treasuryValHash: import_lucid62.Data.Bytes()
 });
 var StableswapParams = StableswapParamsSchema;
 function castStableswapParams(params) {
-  return import_lucid61.Data.castTo(params, StableswapParams);
+  return import_lucid62.Data.castTo(params, StableswapParams);
 }
 
 // src/validators/stableswap-validator.ts
@@ -9470,7 +10023,7 @@ var _stableswapValidator = {
 var mkStableswapValidator = (params) => {
   return {
     type: "PlutusV3",
-    script: (0, import_lucid62.applyParamsToScript)(_stableswapValidator.cborHex, [
+    script: (0, import_lucid63.applyParamsToScript)(_stableswapValidator.cborHex, [
       castStableswapParams(params)
     ])
   };
@@ -9478,7 +10031,7 @@ var mkStableswapValidator = (params) => {
 var mkStableswapValidatorFromSP = (params) => {
   return {
     type: "PlutusV3",
-    script: (0, import_lucid62.applyParamsToScript)(_stableswapValidator.cborHex, [
+    script: (0, import_lucid63.applyParamsToScript)(_stableswapValidator.cborHex, [
       castStableswapParams({
         iassetSymbol: params.iassetSymbol.unCurrencySymbol,
         cdpToken: fromSystemParamsAssetLucid(params.cdpToken),
@@ -9514,7 +10067,7 @@ var mkPythFeedValidator = (params) => {
 var import_ts_pattern22 = require("ts-pattern");
 
 // tests/pyth/endpoints.ts
-var import_lucid63 = require("@lucid-evolution/lucid");
+var import_lucid64 = require("@lucid-evolution/lucid");
 
 // src/validators/always-succeed-validator.ts
 var _alwaysSucceedValidator = {
@@ -9530,29 +10083,29 @@ var alwaysSucceedValidator = {
 };
 
 // tests/pyth/endpoints.ts
-var import_cardano_offchain_common26 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_cardano_offchain_common27 = require("@3rd-eye-labs/cardano-offchain-common");
 var TEST_TRUSTED_SIGNER_PUB_KEY = "4a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71f";
 async function initPyth(lucid) {
-  const pythStateName = (0, import_lucid63.fromText)("Pyth State");
+  const pythStateName = (0, import_lucid64.fromText)("Pyth State");
   const pythStatePolicyId = await mintOneTimeToken(lucid, pythStateName, 1n);
   const pythStateAsset = {
-    currencySymbol: (0, import_lucid63.fromHex)(pythStatePolicyId),
-    tokenName: (0, import_lucid63.fromHex)(pythStateName)
+    currencySymbol: (0, import_lucid64.fromHex)(pythStatePolicyId),
+    tokenName: (0, import_lucid64.fromHex)(pythStateName)
   };
-  const alwaysSucceedsValidatorHash = (0, import_lucid63.validatorToScriptHash)(
+  const alwaysSucceedsValidatorHash = (0, import_lucid64.validatorToScriptHash)(
     alwaysSucceedValidator
   );
   const pythStateDatum = {
     // The governance doesn't matter for the purpose of testing, so we can use any values
     governance: {
-      wormhole: (0, import_lucid63.fromHex)(""),
+      wormhole: (0, import_lucid64.fromHex)(""),
       emitterChain: 0n,
-      emitterAddress: (0, import_lucid63.fromHex)(""),
+      emitterAddress: (0, import_lucid64.fromHex)(""),
       seenSequence: 0n
     },
     trustedSigners: /* @__PURE__ */ new Map([
       [
-        (0, import_lucid63.fromHex)(TEST_TRUSTED_SIGNER_PUB_KEY),
+        (0, import_lucid64.fromHex)(TEST_TRUSTED_SIGNER_PUB_KEY),
         {
           lower_bound: {
             bound_type: {
@@ -9572,25 +10125,25 @@ async function initPyth(lucid) {
     deprecatedWithdrawScripts: /* @__PURE__ */ new Map(),
     // For the purpose of testing, we use the always succeeds validator to validate the Pyth Messages.
     // This means the message signature checking will always succeed for the purpose of emulation testing.
-    withdraw_script: (0, import_lucid63.fromHex)(alwaysSucceedsValidatorHash)
+    withdraw_script: (0, import_lucid64.fromHex)(alwaysSucceedsValidatorHash)
   };
   await runAndAwaitTxBuilder(
     lucid,
     lucid.newTx().pay.ToContract(
-      (0, import_lucid63.credentialToAddress)(lucid.config().network, {
-        hash: (0, import_lucid63.validatorToScriptHash)(alwaysSucceedValidator),
+      (0, import_lucid64.credentialToAddress)(lucid.config().network, {
+        hash: (0, import_lucid64.validatorToScriptHash)(alwaysSucceedValidator),
         type: "Script"
       }),
       { kind: "inline", value: serialisePythStateDatum(pythStateDatum) },
-      (0, import_cardano_offchain_common26.mkAssetsOf)(pythStateAsset, 1n),
+      (0, import_cardano_offchain_common27.mkAssetsOf)(pythStateAsset, 1n),
       alwaysSucceedValidator
     )
   );
   await runAndAwaitTxBuilder(
     lucid,
     lucid.newTx().register.Stake(
-      (0, import_lucid63.credentialToRewardAddress)(lucid.config().network, {
-        hash: (0, import_lucid63.validatorToScriptHash)(alwaysSucceedValidator),
+      (0, import_lucid64.credentialToRewardAddress)(lucid.config().network, {
+        hash: (0, import_lucid64.validatorToScriptHash)(alwaysSucceedValidator),
         type: "Script"
       })
     )
@@ -9614,7 +10167,7 @@ async function initPythConfig(lucid, initialAssets, pythStateAsset) {
         const pythFeedValidator = mkPythFeedValidator(
           fromSysParamsPythFeedParams(val.pythFeedParams)
         );
-        const pythFeedValHash = (0, import_lucid64.validatorToScriptHash)(pythFeedValidator);
+        const pythFeedValHash = (0, import_lucid65.validatorToScriptHash)(pythFeedValidator);
         const pythFeedValScriptRef = await initScriptRef(
           lucid,
           pythFeedValidator
@@ -9622,13 +10175,13 @@ async function initPythConfig(lucid, initialAssets, pythStateAsset) {
         await runAndAwaitTxBuilder(
           lucid,
           lucid.newTx().register.Stake(
-            (0, import_lucid64.credentialToRewardAddress)(lucid.config().network, {
-              hash: (0, import_lucid64.validatorToScriptHash)(pythFeedValidator),
+            (0, import_lucid65.credentialToRewardAddress)(lucid.config().network, {
+              hash: (0, import_lucid65.validatorToScriptHash)(pythFeedValidator),
               type: "Script"
             })
           )
         );
-        const key = `${asset.name}/${(0, import_lucid64.toHex)(collateral.collateralAsset.currencySymbol)}.${(0, import_lucid64.toHex)(collateral.collateralAsset.tokenName)}`;
+        const key = `${asset.name}/${(0, import_lucid65.toHex)(collateral.collateralAsset.currencySymbol)}.${(0, import_lucid65.toHex)(collateral.collateralAsset.tokenName)}`;
         return {
           [key]: {
             params: val.pythFeedParams,
@@ -9680,16 +10233,16 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
   };
   const versionRecordTokenPolicy = mkVersionRecordTokenPolicy({
     upgradeToken: {
-      currencySymbol: (0, import_lucid64.toHex)(upgradeToken.currencySymbol),
-      tokenName: (0, import_lucid64.toHex)(upgradeToken.tokenName)
+      currencySymbol: (0, import_lucid65.toHex)(upgradeToken.currencySymbol),
+      tokenName: (0, import_lucid65.toHex)(upgradeToken.tokenName)
     }
   });
   const versionRecordToken = {
-    currencySymbol: (0, import_lucid64.fromHex)((0, import_lucid64.mintingPolicyToId)(versionRecordTokenPolicy)),
-    tokenName: (0, import_lucid64.fromHex)((0, import_lucid64.fromText)(tn.versionRecord))
+    currencySymbol: (0, import_lucid65.fromHex)((0, import_lucid65.mintingPolicyToId)(versionRecordTokenPolicy)),
+    tokenName: (0, import_lucid65.fromHex)((0, import_lucid65.fromText)(tn.versionRecord))
   };
   const versionRegistryValidator = mkVersionRegistryValidator();
-  const versionRegistryValHash = (0, import_lucid64.validatorToScriptHash)(
+  const versionRegistryValHash = (0, import_lucid65.validatorToScriptHash)(
     versionRegistryValidator
   );
   const cdpCreatorAsset = await mintOneTimeAsset(
@@ -9710,7 +10263,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     versionRecordToken: toSystemParamsAsset(versionRecordToken)
   };
   const collectorValidator = mkCollectorValidatorFromSP(collectorParams);
-  const collectorValHash = (0, import_lucid64.validatorToScriptHash)(collectorValidator);
+  const collectorValHash = (0, import_lucid65.validatorToScriptHash)(collectorValidator);
   const stakingParams = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
@@ -9719,7 +10272,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     indyToken: toSystemParamsAsset(indyAsset),
     collectorValHash
   };
-  const stakingValHash = (0, import_lucid64.validatorToScriptHash)(
+  const stakingValHash = (0, import_lucid65.validatorToScriptHash)(
     mkStakingValidatorFromSP(stakingParams)
   );
   await initStakingManager(lucid, stakingParams);
@@ -9728,9 +10281,9 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     versionRecordToken: toSystemParamsAsset(versionRecordToken)
   };
   const iassetValidator = mkIAssetValidatorFromSP(iassetParams);
-  const iassetValHash = (0, import_lucid64.validatorToScriptHash)(iassetValidator);
+  const iassetValHash = (0, import_lucid65.validatorToScriptHash)(iassetValidator);
   const assetSymbolPolicy = mkIAssetTokenPolicy(cdpToken);
-  const assetSymbol = (0, import_lucid64.mintingPolicyToId)(assetSymbolPolicy);
+  const assetSymbol = (0, import_lucid65.mintingPolicyToId)(assetSymbolPolicy);
   const snapshotEpochToScaleToSumToken = deriveAuthToken(
     stabilityPoolToken,
     tn.snapshotEpochToScaleToSum
@@ -9753,14 +10306,14 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     stakeCredential: spStakingCred
   };
   const stabilityPoolValidator = mkStabilityPoolValidatorFromSP(stabilityPoolParams);
-  const stabilityPoolValHash = (0, import_lucid64.validatorToScriptHash)(stabilityPoolValidator);
+  const stabilityPoolValHash = (0, import_lucid65.validatorToScriptHash)(stabilityPoolValidator);
   const treasuryParams = {
     upgradeToken: toSystemParamsAsset(upgradeToken),
     versionRecordToken: toSystemParamsAsset(versionRecordToken),
     treasuryUtxosStakeCredential: treasuryStakingCred
   };
   const treasuryValidator = mkTreasuryValidatorFromSP(treasuryParams);
-  const treasuryValHash = (0, import_lucid64.validatorToScriptHash)(treasuryValidator);
+  const treasuryValHash = (0, import_lucid65.validatorToScriptHash)(treasuryValidator);
   await initTreasury(
     lucid,
     treasuryParams,
@@ -9783,7 +10336,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
   const interestCollectionValidator = mkInterestCollectionValidatorFromSP(
     interestCollectionParams
   );
-  const interestCollectionValHash = (0, import_lucid64.validatorToScriptHash)(
+  const interestCollectionValHash = (0, import_lucid65.validatorToScriptHash)(
     interestCollectionValidator
   );
   await initInterestCollector(
@@ -9812,10 +10365,10 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     biasTime
   };
   const cdpRedeemValidator = mkCdpRedeemValidatorFromSP(cdpRedeemParams);
-  const cdpRedeemValHash = (0, import_lucid64.validatorToScriptHash)(cdpRedeemValidator);
-  const cdpRedeemRewardAddr = (0, import_lucid64.credentialToRewardAddress)(
+  const cdpRedeemValHash = (0, import_lucid65.validatorToScriptHash)(cdpRedeemValidator);
+  const cdpRedeemRewardAddr = (0, import_lucid65.credentialToRewardAddress)(
     lucid.config().network,
-    (0, import_lucid64.scriptHashToCredential)(cdpRedeemValHash)
+    (0, import_lucid65.scriptHashToCredential)(cdpRedeemValHash)
   );
   await submitTx(lucid, lucid.newTx().register.Stake(cdpRedeemRewardAddr));
   const cdpParams = {
@@ -9834,7 +10387,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     biasTime
   };
   const cdpValidator = mkCdpValidatorFromSP(cdpParams);
-  const cdpValHash = (0, import_lucid64.validatorToScriptHash)(cdpValidator);
+  const cdpValHash = (0, import_lucid65.validatorToScriptHash)(cdpValidator);
   const cdpCreatorParams = {
     cdpCreatorNft: toSystemParamsAsset(cdpCreatorAsset),
     cdpAssetCs: { unCurrencySymbol: assetSymbol },
@@ -9849,7 +10402,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     biasTime: cdpParams.biasTime
   };
   const cdpCreatorValidator = mkCDPCreatorValidatorFromSP(cdpCreatorParams);
-  const cdpCreatorValHash = (0, import_lucid64.validatorToScriptHash)(cdpCreatorValidator);
+  const cdpCreatorValHash = (0, import_lucid65.validatorToScriptHash)(cdpCreatorValidator);
   const stableswapParams = {
     iassetSymbol: { unCurrencySymbol: assetSymbol },
     cdpToken: toSystemParamsAsset(cdpToken),
@@ -9858,7 +10411,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     treasuryValHash
   };
   const stableswapValidator = mkStableswapValidatorFromSP(stableswapParams);
-  const stableswapValHash = (0, import_lucid64.validatorToScriptHash)(stableswapValidator);
+  const stableswapValHash = (0, import_lucid65.validatorToScriptHash)(stableswapValidator);
   await initCollector(lucid, collectorParams, numCollectors);
   const assetInfos = [];
   if (initialAssets.length > 0) {
@@ -9885,9 +10438,9 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
         lucid,
         lucid.newTx().pay.ToAddress(
           await lucid.wallet().address(),
-          (0, import_lucid64.addAssets)(
-            (0, import_cardano_offchain_common27.mkAssetsOf)(iassetToken, 1n),
-            (0, import_cardano_offchain_common27.mkLovelacesOf)(BigInt(totalCollateralAssetsCount) * 5000000n)
+          (0, import_lucid65.addAssets)(
+            (0, import_cardano_offchain_common28.mkAssetsOf)(iassetToken, 1n),
+            (0, import_cardano_offchain_common28.mkLovelacesOf)(BigInt(totalCollateralAssetsCount) * 5000000n)
           )
         )
       );
@@ -9903,9 +10456,9 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
         lucid,
         lucid.newTx().pay.ToAddress(
           await lucid.wallet().address(),
-          (0, import_lucid64.addAssets)(
-            (0, import_cardano_offchain_common27.mkAssetsOf)(cdpCreatorAsset, 1n),
-            (0, import_cardano_offchain_common27.mkLovelacesOf)(BigInt(totalStablePoolsCount) * 5000000n)
+          (0, import_lucid65.addAssets)(
+            (0, import_cardano_offchain_common28.mkAssetsOf)(cdpCreatorAsset, 1n),
+            (0, import_cardano_offchain_common28.mkLovelacesOf)(BigInt(totalStablePoolsCount) * 5000000n)
           )
         )
       );
@@ -9961,7 +10514,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     treasuryValHash
   };
   const executeValidator = mkExecuteValidatorFromSP(executeParams);
-  const executeValHash = (0, import_lucid64.validatorToScriptHash)(executeValidator);
+  const executeValHash = (0, import_lucid65.validatorToScriptHash)(executeValidator);
   const pollShardParams = {
     pollToken: toSystemParamsAsset(pollToken),
     stakingToken: toSystemParamsAsset(stakingToken),
@@ -9969,7 +10522,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     stakingValHash
   };
   const pollShardValidator = mkPollShardValidatorFromSP(pollShardParams);
-  const pollShardValHash = (0, import_lucid64.validatorToScriptHash)(pollShardValidator);
+  const pollShardValHash = (0, import_lucid65.validatorToScriptHash)(pollShardValidator);
   const pollManagerParams = {
     govNFT: toSystemParamsAsset(govNftAsset),
     pollToken: toSystemParamsAsset(pollToken),
@@ -9981,7 +10534,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     treasuryValHash
   };
   const pollManagerValidator = mkPollManagerValidatorFromSP(pollManagerParams);
-  const pollManagerValHash = (0, import_lucid64.validatorToScriptHash)(pollManagerValidator);
+  const pollManagerValHash = (0, import_lucid65.validatorToScriptHash)(pollManagerValidator);
   const govParams = {
     gBiasTime: gBiasTime ? BigInt(gBiasTime) : BigInt(biasTime),
     govNFT: toSystemParamsAsset(govNftAsset),
@@ -9996,7 +10549,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     iassetSymbol: { unCurrencySymbol: assetSymbol }
   };
   const govValidator = mkGovValidatorFromSP(govParams);
-  const govValHash = (0, import_lucid64.validatorToScriptHash)(govValidator);
+  const govValHash = (0, import_lucid65.validatorToScriptHash)(govValidator);
   await initGovernance(
     lucid,
     govParams,
@@ -10012,36 +10565,36 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     versionRecordToken: cdpParams.versionRecordToken
   };
   const robValidator = mkRobValidatorFromSP(robParams);
-  const robValHash = (0, import_lucid64.validatorToScriptHash)(robValidator);
-  const cdpTokenPolicy = mkAuthTokenPolicy(cdpCreatorAsset, (0, import_lucid64.fromText)(tn.cdp));
+  const robValHash = (0, import_lucid65.validatorToScriptHash)(robValidator);
+  const cdpTokenPolicy = mkAuthTokenPolicy(cdpCreatorAsset, (0, import_lucid65.fromText)(tn.cdp));
   const iassetTokenPolicy = mkAuthTokenPolicy(
     upgradeToken,
-    (0, import_lucid64.fromText)(tn.iasset)
+    (0, import_lucid65.fromText)(tn.iasset)
   );
   const accountTokenPolicy = mkAuthTokenPolicy(
     stabilityPoolToken,
-    (0, import_lucid64.fromText)(tn.account)
+    (0, import_lucid65.fromText)(tn.account)
   );
   const stabilityPoolTokenPolicy = mkAuthTokenPolicy(
     upgradeToken,
-    (0, import_lucid64.fromText)(tn.stabilityPool)
+    (0, import_lucid65.fromText)(tn.stabilityPool)
   );
   const pollTokenPolicy = mkAuthTokenPolicy(
     govNftAsset,
-    (0, import_lucid64.fromText)(tn.pollManager)
+    (0, import_lucid65.fromText)(tn.pollManager)
   );
   const stakingTokenPolicy = mkAuthTokenPolicy(
     stakingManagerAsset,
-    (0, import_lucid64.fromText)(tn.staking)
+    (0, import_lucid65.fromText)(tn.staking)
   );
   const collateralAssetAuthTokenPolicy = mkAuthTokenPolicy(
     iassetToken,
-    (0, import_lucid64.fromText)(tn.collateralAsset)
+    (0, import_lucid65.fromText)(tn.collateralAsset)
   );
-  const upgradeTokenPolicy = mkAuthTokenPolicy(pollToken, (0, import_lucid64.fromText)(tn.upgrade));
+  const upgradeTokenPolicy = mkAuthTokenPolicy(pollToken, (0, import_lucid65.fromText)(tn.upgrade));
   const snapshotEpochToScaleToSumTokenPolicy = mkAuthTokenPolicy(
     stabilityPoolToken,
-    (0, import_lucid64.fromText)(tn.snapshotEpochToScaleToSum)
+    (0, import_lucid65.fromText)(tn.snapshotEpochToScaleToSum)
   );
   const sysParams = {
     cdpParams,
@@ -10185,19 +10738,19 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
 }
 
 // src/contracts/stableswap/helpers.ts
-var import_lucid65 = require("@lucid-evolution/lucid");
+var import_lucid66 = require("@lucid-evolution/lucid");
 
 // src/contracts/stableswap/types-new.ts
-var import_cardano_offchain_common28 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_cardano_offchain_common29 = require("@3rd-eye-labs/cardano-offchain-common");
 var import_evolution20 = require("@evolution-sdk/evolution");
-var import_fp_ts20 = require("fp-ts");
+var import_fp_ts21 = require("fp-ts");
 var import_effect3 = require("effect");
 var OpaqueData4 = import_effect3.Schema.typeSchema(import_evolution20.Data.DataSchema);
 var StableswapOrderDatumSchema = import_evolution20.TSchema.Struct({
   iasset: import_evolution20.TSchema.ByteArray,
-  collateralAsset: import_cardano_offchain_common28.AssetClassSchema,
+  collateralAsset: import_cardano_offchain_common29.AssetClassSchema,
   owner: import_evolution20.TSchema.ByteArray,
-  destination: import_cardano_offchain_common28.AddressSchema,
+  destination: import_cardano_offchain_common29.AddressSchema,
   destinationInlineDatum: import_evolution20.TSchema.NullOr(OpaqueData4),
   maxExecutionFee: import_evolution20.TSchema.Integer,
   maxFeeRatio: RationalSchema
@@ -10222,7 +10775,7 @@ var StableswapOrderRedeemerSchema = import_evolution20.TSchema.Union(
 );
 var StableswapOutputDatumSchema = import_evolution20.TSchema.Tuple([
   import_evolution20.TSchema.ByteArray,
-  import_cardano_offchain_common28.OutputReferenceSchema
+  import_cardano_offchain_common29.OutputReferenceSchema
 ]);
 function serialiseStableswapOrderDatum(d) {
   return import_evolution20.Data.withSchema(
@@ -10232,22 +10785,22 @@ function serialiseStableswapOrderDatum(d) {
 }
 function parseStableswapOrderDatum(datum) {
   try {
-    return import_fp_ts20.option.some(
+    return import_fp_ts21.option.some(
       import_evolution20.Data.withSchema(
         StableswapOrderDatumSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(datum)
     );
   } catch (_) {
-    return import_fp_ts20.option.none;
+    return import_fp_ts21.option.none;
   }
 }
 function parseStableswapOrderDatumOrThrow(datum) {
-  return import_fp_ts20.function.pipe(
+  return import_fp_ts21.function.pipe(
     parseStableswapOrderDatum(datum),
-    import_fp_ts20.option.match(() => {
+    import_fp_ts21.option.match(() => {
       throw new Error("Expected a Stableswap Order datum.");
-    }, import_fp_ts20.function.identity)
+    }, import_fp_ts21.function.identity)
   );
 }
 function serialiseStableswapOutputDatum(d) {
@@ -10264,22 +10817,22 @@ function serialiseStableswapOrderRedeemer(r) {
 }
 function parseStableswapOrderRedeemer(redeemerCborHex) {
   try {
-    return import_fp_ts20.option.some(
+    return import_fp_ts21.option.some(
       import_evolution20.Data.withSchema(
         StableswapOrderRedeemerSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(redeemerCborHex)
     );
   } catch (_) {
-    return import_fp_ts20.option.none;
+    return import_fp_ts21.option.none;
   }
 }
 function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
-  return import_fp_ts20.function.pipe(
+  return import_fp_ts21.function.pipe(
     parseStableswapOrderRedeemer(redeemerCborHex),
-    import_fp_ts20.option.match(() => {
+    import_fp_ts21.option.match(() => {
       throw new Error("Expected a Stableswap Order redeemer.");
-    }, import_fp_ts20.function.identity)
+    }, import_fp_ts21.function.identity)
   );
 }
 
@@ -10289,9 +10842,9 @@ var BASE_MAX_EXECUTION_FEE = 1000000n;
 function createDestinationDatum(datum, outRef) {
   if (!datum) {
     return serialiseStableswapOutputDatum([
-      (0, import_lucid65.fromHex)((0, import_lucid65.fromText)("IndigoStableswap")),
+      (0, import_lucid66.fromHex)((0, import_lucid66.fromText)("IndigoStableswap")),
       {
-        txHash: (0, import_lucid65.fromHex)(outRef.txHash),
+        txHash: (0, import_lucid66.fromHex)(outRef.txHash),
         outputIndex: BigInt(outRef.outputIndex)
       }
     ]);
@@ -10300,28 +10853,28 @@ function createDestinationDatum(datum, outRef) {
 }
 
 // src/contracts/stableswap/transactions.ts
-var import_lucid66 = require("@lucid-evolution/lucid");
-var import_cardano_offchain_common29 = require("@3rd-eye-labs/cardano-offchain-common");
-var import_fp_ts21 = require("fp-ts");
+var import_lucid67 = require("@lucid-evolution/lucid");
+var import_cardano_offchain_common30 = require("@3rd-eye-labs/cardano-offchain-common");
+var import_fp_ts22 = require("fp-ts");
 var import_Array3 = require("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();
-  const pkh = (0, import_lucid66.paymentCredentialOf)(myAddress);
+  const pkh = (0, import_lucid67.paymentCredentialOf)(myAddress);
   const datum = {
-    iasset: (0, import_lucid66.fromHex)((0, import_lucid66.fromText)(iasset)),
+    iasset: (0, import_lucid67.fromHex)((0, import_lucid67.fromText)(iasset)),
     collateralAsset,
-    owner: (0, import_lucid66.fromHex)(pkh.hash),
-    destination: (0, import_cardano_offchain_common29.addressFromBech32)(destinationAddress ?? myAddress),
+    owner: (0, import_lucid67.fromHex)(pkh.hash),
+    destination: (0, import_cardano_offchain_common30.addressFromBech32)(destinationAddress ?? myAddress),
     destinationInlineDatum: destinationInlineDatum ?? null,
     maxExecutionFee,
     maxFeeRatio: maxFeeRatio ?? (minting ? poolDatum.mintingFeeRatio : poolDatum.redemptionFeeRatio)
   };
-  const assetsToSwap = minting ? (0, import_cardano_offchain_common29.mkAssetsOf)(collateralAsset, amount) : (0, import_cardano_offchain_common29.mkAssetsOf)(
+  const assetsToSwap = minting ? (0, import_cardano_offchain_common30.mkAssetsOf)(collateralAsset, amount) : (0, import_cardano_offchain_common30.mkAssetsOf)(
     {
-      currencySymbol: (0, import_lucid66.fromHex)(
+      currencySymbol: (0, import_lucid67.fromHex)(
         params.stableswapParams.iassetSymbol.unCurrencySymbol
       ),
-      tokenName: (0, import_lucid66.fromHex)((0, import_lucid66.fromText)(iasset))
+      tokenName: (0, import_lucid67.fromHex)((0, import_lucid67.fromText)(iasset))
     },
     amount
   );
@@ -10339,8 +10892,8 @@ async function createStableswapOrder(iasset, collateralAsset, amount, minting, p
   );
   const roundedExpectedOutputLovelaces = (expectedOutputLovelaces / 1000000n + 1n) * 1000000n;
   return lucid.newTx().pay.ToContract(
-    (0, import_lucid66.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid66.validatorToScriptHash)(
+    (0, import_lucid67.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid67.validatorToScriptHash)(
         mkStableswapValidatorFromSP(params.stableswapParams)
       ),
       type: "Script"
@@ -10349,16 +10902,16 @@ async function createStableswapOrder(iasset, collateralAsset, amount, minting, p
       kind: "inline",
       value: serialiseStableswapOrderDatum(datum)
     },
-    (0, import_lucid66.addAssets)(
+    (0, import_lucid67.addAssets)(
       assetsToSwap,
-      (0, import_cardano_offchain_common29.mkLovelacesOf)(
+      (0, import_cardano_offchain_common30.mkLovelacesOf)(
         roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces
       )
     )
   );
 }
 async function cancelStableswapOrder(stableswapOrderOref, sysParams, lucid) {
-  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
         sysParams.scriptReferences.stableswapValidatorRef
@@ -10366,20 +10919,20 @@ async function cancelStableswapOrder(stableswapOrderOref, sysParams, lucid) {
     ]),
     (_) => new Error("Expected a single Stableswap Ref Script UTXO")
   );
-  const stableswapOrderUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapOrderUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([stableswapOrderOref]),
     (_) => new Error("Expected a single Stableswap Order UTXO.")
   );
   const stableswapOrderDatum = parseStableswapOrderDatumOrThrow(
-    (0, import_cardano_offchain_common29.getInlineDatumOrThrow)(stableswapOrderUtxo)
+    (0, import_cardano_offchain_common30.getInlineDatumOrThrow)(stableswapOrderUtxo)
   );
   return lucid.newTx().readFrom([stableswapScriptRefUtxo]).collectFrom(
     [stableswapOrderUtxo],
     serialiseStableswapOrderRedeemer("CancelStableswapOrder")
-  ).addSignerKey((0, import_lucid66.toHex)(stableswapOrderDatum.owner));
+  ).addSignerKey((0, import_lucid67.toHex)(stableswapOrderDatum.owner));
 }
 async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPoolOref, treasuryOref, sysParams, lucid) {
-  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
         sysParams.scriptReferences.stableswapValidatorRef
@@ -10387,13 +10940,13 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     ]),
     (_) => new Error("Expected a single Stableswap Ref Script UTXO")
   );
-  const cdpScriptRefUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const cdpScriptRefUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
     ]),
     (_) => new Error("Expected a single CDP Ref Script UTXO")
   );
-  const iAssetTokenPolicyRefScriptUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const iAssetTokenPolicyRefScriptUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
         sysParams.scriptReferences.iAssetTokenPolicyRef
@@ -10405,7 +10958,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     throw new Error("At least one order must be provided.");
   }
   const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
-  const sortedStableswapOrderUtxos = (0, import_lucid66.sortUTxOs)(
+  const sortedStableswapOrderUtxos = (0, import_lucid67.sortUTxOs)(
     stableswapOrderUtxos,
     "Canonical"
   );
@@ -10414,32 +10967,32 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
   }
   const mainOrderUtxo = sortedStableswapOrderUtxos[0];
   const mainOrderDatum = parseStableswapOrderDatumOrThrow(
-    (0, import_cardano_offchain_common29.getInlineDatumOrThrow)(mainOrderUtxo)
+    (0, import_cardano_offchain_common30.getInlineDatumOrThrow)(mainOrderUtxo)
   );
   const iassetAc = {
-    currencySymbol: (0, import_lucid66.fromHex)(
+    currencySymbol: (0, import_lucid67.fromHex)(
       sysParams.stableswapParams.iassetSymbol.unCurrencySymbol
     ),
     tokenName: mainOrderDatum.iasset
   };
   const collateralAc = mainOrderDatum.collateralAsset;
-  const stableswapPoolUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapPoolUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([stableswapPoolOref]),
     (_) => new Error("Expected a single cdp UTXO")
   );
   const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
-    (0, import_cardano_offchain_common29.getInlineDatumOrThrow)(stableswapPoolUtxo)
+    (0, import_cardano_offchain_common30.getInlineDatumOrThrow)(stableswapPoolUtxo)
   );
   const ordersInfo = sortedStableswapOrderUtxos.map(
     (orderUtxo) => {
       const orderDatum = parseStableswapOrderDatumOrThrow(
-        (0, import_cardano_offchain_common29.getInlineDatumOrThrow)(orderUtxo)
+        (0, import_cardano_offchain_common30.getInlineDatumOrThrow)(orderUtxo)
       );
-      if ((0, import_lucid66.toHex)(orderDatum.iasset) != (0, import_lucid66.toHex)(mainOrderDatum.iasset) || (0, import_lucid66.toHex)(orderDatum.collateralAsset.currencySymbol) != (0, import_lucid66.toHex)(mainOrderDatum.collateralAsset.currencySymbol) || (0, import_lucid66.toHex)(orderDatum.collateralAsset.tokenName) != (0, import_lucid66.toHex)(mainOrderDatum.collateralAsset.tokenName)) {
+      if ((0, import_lucid67.toHex)(orderDatum.iasset) != (0, import_lucid67.toHex)(mainOrderDatum.iasset) || (0, import_lucid67.toHex)(orderDatum.collateralAsset.currencySymbol) != (0, import_lucid67.toHex)(mainOrderDatum.collateralAsset.currencySymbol) || (0, import_lucid67.toHex)(orderDatum.collateralAsset.tokenName) != (0, import_lucid67.toHex)(mainOrderDatum.collateralAsset.tokenName)) {
         throw new Error("Wrong batch of orders");
       }
-      const suppliedIasset = (0, import_cardano_offchain_common29.assetClassValueOf)(orderUtxo.assets, iassetAc);
-      const suppliedCollateralAsset = (0, import_cardano_offchain_common29.assetClassValueOf)(
+      const suppliedIasset = (0, import_cardano_offchain_common30.assetClassValueOf)(orderUtxo.assets, iassetAc);
+      const suppliedCollateralAsset = (0, import_cardano_offchain_common30.assetClassValueOf)(
         orderUtxo.assets,
         collateralAc
       );
@@ -10563,9 +11116,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       }
     }
   );
-  const totalSwapInfo = import_fp_ts21.function.pipe(
+  const totalSwapInfo = import_fp_ts22.function.pipe(
     ordersInfo,
-    import_fp_ts21.array.reduce(
+    import_fp_ts22.array.reduce(
       {
         suppliedCollateralAsset: 0n,
         suppliedIasset: 0n,
@@ -10607,20 +11160,20 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       kind: "inline",
       value: serialiseStableswapPoolDatum(stableswapPoolDatum)
     },
-    collateralAmtChangePool != 0n ? (0, import_lucid66.addAssets)(
+    collateralAmtChangePool != 0n ? (0, import_lucid67.addAssets)(
       stableswapPoolUtxo.assets,
-      (0, import_cardano_offchain_common29.mkAssetsOf)(collateralAc, collateralAmtChangePool)
+      (0, import_cardano_offchain_common30.mkAssetsOf)(collateralAc, collateralAmtChangePool)
     ) : stableswapPoolUtxo.assets
   ).setMinFee(2055720n);
   if (amountToMint !== 0n) {
-    tx.mintAssets((0, import_cardano_offchain_common29.mkAssetsOf)(iassetAc, amountToMint), import_lucid66.Data.void());
+    tx.mintAssets((0, import_cardano_offchain_common30.mkAssetsOf)(iassetAc, amountToMint), import_lucid67.Data.void());
   }
-  import_fp_ts21.function.pipe(
+  import_fp_ts22.function.pipe(
     ordersInfo,
-    import_fp_ts21.array.reduce(tx, (acc, orderInfo) => {
+    import_fp_ts22.array.reduce(tx, (acc, orderInfo) => {
       return acc.collectFrom(
         [orderInfo.utxo],
-        (0, import_cardano_offchain_common29.isSameOutRef)(orderInfo.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
+        (0, import_cardano_offchain_common30.isSameOutRef)(orderInfo.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
           kind: "selected",
           makeRedeemer: (inputIndices) => {
             return serialiseStableswapOrderRedeemer({
@@ -10633,7 +11186,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
           inputs: [orderInfo.utxo, mainOrderUtxo]
         }
       ).pay.ToAddressWithData(
-        (0, import_cardano_offchain_common29.addressToBech32)(orderInfo.datum.destination, lucid.config().network),
+        (0, import_cardano_offchain_common30.addressToBech32)(orderInfo.datum.destination, lucid.config().network),
         {
           kind: "inline",
           value: createDestinationDatum(
@@ -10641,13 +11194,13 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
             orderInfo.utxo
           )
         },
-        (0, import_lucid66.addAssets)(
+        (0, import_lucid67.addAssets)(
           // Currently, we always take the max execution fee from the order utxo.
           // This can be improved so that we take the actual execution fee.
-          (0, import_cardano_offchain_common29.mkLovelacesOf)(
-            (0, import_cardano_offchain_common29.lovelacesAmt)(orderInfo.utxo.assets) - orderInfo.datum.maxExecutionFee
+          (0, import_cardano_offchain_common30.mkLovelacesOf)(
+            (0, import_cardano_offchain_common30.lovelacesAmt)(orderInfo.utxo.assets) - orderInfo.datum.maxExecutionFee
           ),
-          orderInfo.swapInfo.owedIasset > 0 ? (0, import_cardano_offchain_common29.mkAssetsOf)(iassetAc, orderInfo.swapInfo.owedIasset) : (0, import_cardano_offchain_common29.mkAssetsOf)(
+          orderInfo.swapInfo.owedIasset > 0 ? (0, import_cardano_offchain_common30.mkAssetsOf)(iassetAc, orderInfo.swapInfo.owedIasset) : (0, import_cardano_offchain_common30.mkAssetsOf)(
             collateralAc,
             orderInfo.swapInfo.owedCollateralAsset
           )
@@ -10670,7 +11223,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
   return tx;
 }
 async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRef, newMintingFeeRatio, newRedemptionFeeRatio, sysParams, lucid) {
-  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapScriptRefUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
         sysParams.scriptReferences.stableswapValidatorRef
@@ -10678,22 +11231,22 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
     ]),
     (_) => new Error("Expected a single Stableswap Ref Script UTXO")
   );
-  const cdpScriptRefUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const cdpScriptRefUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
     ]),
     (_) => new Error("Expected a single CDP Ref Script UTXO")
   );
-  const stableswapPool = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapPool = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([stableswapPoolOutRef]),
     (_) => new Error("Expected a single Stableswap Pool UTXO.")
   );
-  const stableswapFeeUtxo = (0, import_cardano_offchain_common29.matchSingle)(
+  const stableswapFeeUtxo = (0, import_cardano_offchain_common30.matchSingle)(
     await lucid.utxosByOutRef([stableswapFeeOutRef]),
     (_) => new Error("Expected a single Stableswap Fee UTXO.")
   );
   const stableswapPoolDatum = parseStableswapPoolDatumOrThrow(
-    (0, import_cardano_offchain_common29.getInlineDatumOrThrow)(stableswapPool)
+    (0, import_cardano_offchain_common30.getInlineDatumOrThrow)(stableswapPool)
   );
   const newStableswapPoolDatum = {
     ...stableswapPoolDatum,
@@ -10721,7 +11274,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
       value: serialiseStableswapPoolDatum(newStableswapPoolDatum)
     },
     stableswapPool.assets
-  ).addSignerKey((0, import_lucid66.toHex)(stableswapPoolDatum.feeManager)).setMinFee(1038402n);
+  ).addSignerKey((0, import_lucid67.toHex)(stableswapPoolDatum.feeManager)).setMinFee(1038402n);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -10748,6 +11301,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   InterestOracleDatumSchema,
   InterestOracleParamsSchema,
   MAX_E2S2S_ENTRIES_COUNT,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN,
   MIN_ROB_COLLATERAL_AMT,
   ONE_DAY,
   ONE_HOUR,
@@ -10782,6 +11336,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   adjustStakingPosition,
   alwaysFailValidator,
   annulRequest,
+  approximateLeverageRedemptions,
   attachOracle,
   balance,
   batchCollectInterest,
@@ -10792,8 +11347,11 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   burnCdp,
   calculateAccruedInterest,
   calculateAdaReward,
+  calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalCollateralForRedemption,
   calculateUnitaryInterest,
   calculateUnitaryInterestSinceOracleLastUpdated,
   cancelRob,
@@ -10859,9 +11417,9 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   getAssetClassComparisonStr,
   getInlineDatumOrThrow,
   getPythFeedConfig,
-  getRandomElement,
   getUpdatedAccountDeposit,
   handleOracleForCollateralAsset,
+  iassetValueOfCollateral,
   init,
   initCDPCreator,
   initCollector,
@@ -10875,8 +11433,10 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   initTreasury,
   initializeAsset,
   insertSorted,
+  isBuyOrderFullyRedeemed,
   isFullyRedeemed,
   isSameEpochToScaleKey,
+  leverageCdpWithRob,
   liquidateCdp,
   liquidationHelper,
   loadSystemParamsFromFile,
@@ -10940,10 +11500,6 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   parseIAssetDatumOrThrow,
   parseInterestCollectionDatum,
   parseInterestOracleDatum,
-  parsePollManager,
-  parsePollManagerOrThrow,
-  parsePollShard,
-  parsePollShardOrThrow,
   parsePriceOracleDatum,
   parsePythStateDatum,
   parseRobDatum,
@@ -10964,8 +11520,8 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   parseStakingPosition,
   parseStakingPositionOrThrow,
   partitionEpochToScaleToSums,
-  pollPassQuorum,
   processSpRequest,
+  randomRobsSubsetSatisfyingTargetCollateral,
   rationalAdd,
   rationalCeil,
   rationalDiv,
@@ -10984,7 +11540,10 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   requestSpAccountClosure,
   requestSpAccountCreation,
   rewardSnapshotPrecision,
-  robAmountToSpend,
+  robAmtToSpend,
+  robBuyOrderSummary,
+  robCollateralAmtToSpend,
+  robIAssetAmtToSpend,
   runCreateScriptRefTx,
   runOneShotMintTx,
   scriptRef,
@@ -11001,9 +11560,6 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum,
-  serialisePollDatum,
-  serialisePollManagerRedeemer,
-  serialisePollShardRedeemer,
   serialisePriceOracleDatum,
   serialisePriceOracleRedeemer,
   serialisePythFeedParams,
@@ -11032,6 +11588,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   startPriceOracleTx,
   submitTx,
   sum,
+  summarizeActualLeverageRedemptions,
   toAssetClassFromLucid,
   toDataDerivedPythPrice,
   toSystemParamsAsset,