@indigo-labs/indigo-sdk 0.2.1 → 0.2.4

package/dist/index.js

@@ -56,6 +56,8 @@ __export(index_exports, {
   LRPDatumSchema: () => LRPDatumSchema,
   LRPParamsSchema: () => LRPParamsSchema,
   LRPRedeemerSchema: () => LRPRedeemerSchema,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN: () => MAX_REDEMPTIONS_WITH_CDP_OPEN,
+  MIN_LRP_COLLATERAL_AMT: () => MIN_LRP_COLLATERAL_AMT,
   ONE_DAY: () => ONE_DAY,
   ONE_HOUR: () => ONE_HOUR,
   ONE_SECOND: () => ONE_SECOND,
@@ -86,12 +88,17 @@ __export(index_exports, {
   adjustSpAccount: () => adjustSpAccount,
   adjustStakingPosition: () => adjustStakingPosition,
   adjustmentHelper: () => adjustmentHelper,
+  approximateLeverageRedemptions: () => approximateLeverageRedemptions,
   assetClassToUnit: () => assetClassToUnit,
   assetClassValueOf: () => assetClassValueOf,
   balance: () => balance,
+  buildRedemptionsTx: () => buildRedemptionsTx,
   burnCdp: () => burnCdp,
+  calculateCollateralRatioFromLeverage: () => calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt: () => calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio: () => calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt: () => calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalAdaForRedemption: () => calculateTotalAdaForRedemption,
   cancelLrp: () => cancelLrp,
   castCDPCreatorParams: () => castCDPCreatorParams,
   castCdpParams: () => castCdpParams,
@@ -103,6 +110,7 @@ __export(index_exports, {
   castPollShardParams: () => castPollShardParams,
   castPriceOracleParams: () => castPriceOracleParams,
   castStabilityPoolParams: () => castStabilityPoolParams,
+  castStakingParams: () => castStakingParams,
   castVersionRecordTokenParams: () => castVersionRecordTokenParams,
   cdpCollateralRatioPercentage: () => cdpCollateralRatioPercentage,
   claimLrp: () => claimLrp,
@@ -115,6 +123,7 @@ __export(index_exports, {
   createShardsChunks: () => createShardsChunks,
   createSpAccount: () => createSpAccount,
   depositCdp: () => depositCdp,
+  distributeAda: () => distributeAda,
   endProposal: () => endProposal,
   executeProposal: () => executeProposal,
   feedInterestOracle: () => feedInterestOracle,
@@ -130,12 +139,15 @@ __export(index_exports, {
   getSumFromEpochToScaleToSum: () => getSumFromEpochToScaleToSum,
   initEpochToScaleToSumMap: () => initEpochToScaleToSumMap,
   initSpSnapshot: () => initSpSnapshot,
+  insertSorted: () => insertSorted,
   isAssetsZero: () => isAssetsZero,
+  leverageCdpWithLrp: () => leverageCdpWithLrp,
   liquidateCdp: () => liquidateCdp,
   liquidationHelper: () => liquidationHelper,
   loadSystemParamsFromFile: () => loadSystemParamsFromFile,
   loadSystemParamsFromUrl: () => loadSystemParamsFromUrl,
   lovelacesAmt: () => lovelacesAmt,
+  lrpRedeemableLovelacesInclReimb: () => lrpRedeemableLovelacesInclReimb,
   matchSingle: () => matchSingle,
   mergeCdps: () => mergeCdps,
   mergeShards: () => mergeShards,
@@ -175,10 +187,15 @@ __export(index_exports, {
   parseIAssetDatumOrThrow: () => parseIAssetDatumOrThrow,
   parseInterestOracleDatum: () => parseInterestOracleDatum,
   parseLrpDatum: () => parseLrpDatum,
+  parseLrpDatumOrThrow: () => parseLrpDatumOrThrow,
   parsePriceOracleDatum: () => parsePriceOracleDatum,
   parseSnapshotEpochToScaleToSumDatum: () => parseSnapshotEpochToScaleToSumDatum,
   parseStabilityPoolDatum: () => parseStabilityPoolDatum,
+  parseStakingManagerDatum: () => parseStakingManagerDatum,
+  parseStakingPosition: () => parseStakingPosition,
+  parseStakingPositionOrThrow: () => parseStakingPositionOrThrow,
   processSpRequest: () => processSpRequest,
+  randomLrpsSubsetSatisfyingTargetLovelaces: () => randomLrpsSubsetSatisfyingTargetLovelaces,
   redeemCdp: () => redeemCdp,
   redeemLrp: () => redeemLrp,
   runCreateScriptRefTx: () => runCreateScriptRefTx,
@@ -202,12 +219,16 @@ __export(index_exports, {
   serialisePriceOracleRedeemer: () => serialisePriceOracleRedeemer,
   serialiseStabilityPoolDatum: () => serialiseStabilityPoolDatum,
   serialiseStabilityPoolRedeemer: () => serialiseStabilityPoolRedeemer,
+  serialiseStakingDatum: () => serialiseStakingDatum,
+  serialiseStakingRedeemer: () => serialiseStakingRedeemer,
   setSumInEpochToScaleToSum: () => setSumInEpochToScaleToSum,
+  shuffle: () => shuffle,
   spAdd: () => spAdd,
   spDiv: () => spDiv,
   spMul: () => spMul,
   spSub: () => spSub,
   startInterestOracle: () => startInterestOracle,
+  summarizeActualLeverageRedemptions: () => summarizeActualLeverageRedemptions,
   toSystemParamsAsset: () => toSystemParamsAsset,
   treasuryFeeTx: () => treasuryFeeTx,
   updatePoolSnapshotWithdrawalFee: () => updatePoolSnapshotWithdrawalFee,
@@ -217,7 +238,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/contracts/cdp/transactions.ts
-var import_lucid17 = require("@lucid-evolution/lucid");
+var import_lucid18 = require("@lucid-evolution/lucid");
 
 // src/types/system-params.ts
 var import_lucid = require("@lucid-evolution/lucid");
@@ -1006,12 +1027,23 @@ function calculateMinCollateralCappedIAssetRedemptionAmt(collateralAmt, mintedAm
 }
 
 // src/utils/bigint-utils.ts
+var import_fp_ts3 = require("fp-ts");
 function bigintMax(a, b) {
   return a > b ? a : b;
 }
 function bigintMin(a, b) {
   return a < b ? a : b;
 }
+function sum(arr) {
+  return import_fp_ts3.array.reduce(0n, (acc, val) => acc + val)(arr);
+}
+function fromDecimal(val) {
+  return BigInt(val.toString());
+}
+var BigIntOrd = {
+  equals: (x, y) => x === y,
+  compare: (first, second) => first < second ? -1 : first > second ? 1 : 0
+};
 
 // src/contracts/stability-pool/types-new.ts
 var import_evolution2 = require("@evolution-sdk/evolution");
@@ -1187,14 +1219,14 @@ function getSumFromEpochToScaleToSum(e2s2s, epoch, scale) {
   }
   return void 0;
 }
-function setSumInEpochToScaleToSum(e2s2s, epoch, scale, sum) {
+function setSumInEpochToScaleToSum(e2s2s, epoch, scale, sum2) {
   const map = /* @__PURE__ */ new Map();
   for (const [key, value] of e2s2s.entries()) {
     if (!(key.epoch === epoch && key.scale === scale)) {
       map.set(key, value);
     }
   }
-  map.set({ epoch, scale }, sum);
+  map.set({ epoch, scale }, sum2);
   return map;
 }
 function getAccountReward(account, e2s2s) {
@@ -1368,10 +1400,24 @@ function liquidationHelper(spContent, iassetBurnAmt, reward) {
 }
 
 // src/contracts/cdp/transactions.ts
-var import_fp_ts3 = require("fp-ts");
+var import_fp_ts4 = require("fp-ts");
 
 // src/contracts/collector/transactions.ts
+var import_lucid15 = require("@lucid-evolution/lucid");
+
+// src/contracts/collector/types.ts
 var import_lucid14 = require("@lucid-evolution/lucid");
+var CollectorRedeemerSchema = import_lucid14.Data.Enum([
+  import_lucid14.Data.Literal("Collect"),
+  import_lucid14.Data.Literal("DistributeToStakers"),
+  import_lucid14.Data.Literal("UpgradeVersion")
+]);
+var CollectorRedeemer = CollectorRedeemerSchema;
+function serialiseCollectorRedeemer(redeemer) {
+  return import_lucid14.Data.to(redeemer, CollectorRedeemer);
+}
+
+// src/contracts/collector/transactions.ts
 async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   const collectorUtxo = matchSingle(
     await lucid.utxosByOutRef([collectorOref]),
@@ -1383,9 +1429,9 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
     ]),
     (_) => new Error("Expected a single collector Ref Script UTXO")
   );
-  tx.collectFrom([collectorUtxo], import_lucid14.Data.to(new import_lucid14.Constr(0, []))).pay.ToContract(
+  tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
-    { kind: "inline", value: import_lucid14.Data.to(new import_lucid14.Constr(0, [])) },
+    { kind: "inline", value: import_lucid15.Data.void() },
     {
       ...collectorUtxo.assets,
       lovelace: collectorUtxo.assets.lovelace + fee
@@ -1394,34 +1440,34 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
 }
 
 // src/contracts/treasury/transactions.ts
-var import_lucid16 = require("@lucid-evolution/lucid");
+var import_lucid17 = require("@lucid-evolution/lucid");
 
 // src/contracts/treasury/types.ts
-var import_lucid15 = require("@lucid-evolution/lucid");
-var TreasuryParamsSchema = import_lucid15.Data.Object({
+var import_lucid16 = require("@lucid-evolution/lucid");
+var TreasuryParamsSchema = import_lucid16.Data.Object({
   upgradeToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  treasuryUtxosStakeCredential: import_lucid15.Data.Nullable(StakeCredentialSchema)
+  treasuryUtxosStakeCredential: import_lucid16.Data.Nullable(StakeCredentialSchema)
 });
-var TreasuryRedeemerSchema = import_lucid15.Data.Enum([
-  import_lucid15.Data.Literal("Withdraw"),
-  import_lucid15.Data.Literal("PrepareWithdraw"),
-  import_lucid15.Data.Literal("Split"),
-  import_lucid15.Data.Literal("Merge"),
-  import_lucid15.Data.Literal("CollectAda"),
-  import_lucid15.Data.Literal("UpgradeVersion")
+var TreasuryRedeemerSchema = import_lucid16.Data.Enum([
+  import_lucid16.Data.Literal("Withdraw"),
+  import_lucid16.Data.Literal("PrepareWithdraw"),
+  import_lucid16.Data.Literal("Split"),
+  import_lucid16.Data.Literal("Merge"),
+  import_lucid16.Data.Literal("CollectAda"),
+  import_lucid16.Data.Literal("UpgradeVersion")
 ]);
 var TreasuryRedeemer = TreasuryRedeemerSchema;
-var WithdrawalOutputDatumSchema = import_lucid15.Data.Tuple([
-  import_lucid15.Data.Bytes(),
+var WithdrawalOutputDatumSchema = import_lucid16.Data.Tuple([
+  import_lucid16.Data.Bytes(),
   OutputReferenceSchema
 ]);
 var WithdrawalOutputDatum = WithdrawalOutputDatumSchema;
 function serialiseWithdrawalOutputDatum(d) {
-  return import_lucid15.Data.to(d, WithdrawalOutputDatum);
+  return import_lucid16.Data.to(d, WithdrawalOutputDatum);
 }
 function serialiseTreasuryRedeemer(redeemer) {
-  return import_lucid15.Data.to(redeemer, TreasuryRedeemer);
+  return import_lucid16.Data.to(redeemer, TreasuryRedeemer);
 }
 
 // src/contracts/treasury/transactions.ts
@@ -1440,15 +1486,15 @@ async function treasuryFeeTx(fee, lucid, sysParams, tx, treasuryOref) {
   );
   tx.readFrom([treasuryRefScriptUtxo]).collectFrom([treasuryUtxo], serialiseTreasuryRedeemer("CollectAda")).pay.ToContract(
     treasuryUtxo.address,
-    { kind: "inline", value: import_lucid16.Data.void() },
-    (0, import_lucid16.addAssets)(treasuryUtxo.assets, mkLovelacesOf(fee))
+    { kind: "inline", value: import_lucid17.Data.void() },
+    (0, import_lucid17.addAssets)(treasuryUtxo.assets, mkLovelacesOf(fee))
   );
 }
 
 // src/contracts/cdp/transactions.ts
 async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid17.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const [pkh, skh] = await addrDetails(lucid);
   const cdpCreatorRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -1524,7 +1570,7 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     cdpCreatorRefScriptUtxo,
     cdpAuthTokenPolicyRefScriptUtxo,
     iAssetTokenPolicyRefScriptUtxo
-  ]).mintAssets(cdpNftVal, import_lucid17.Data.void()).mintAssets(iassetTokensVal, import_lucid17.Data.void()).collectFrom(
+  ]).mintAssets(cdpNftVal, import_lucid18.Data.void()).mintAssets(iassetTokensVal, import_lucid18.Data.void()).collectFrom(
     [cdpCreatorUtxo],
     serialiseCDPCreatorRedeemer({
       CreateCDP: {
@@ -1553,10 +1599,10 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
         }
       })
     },
-    (0, import_lucid17.addAssets)(cdpNftVal, mkLovelacesOf(collateralAmount))
+    (0, import_lucid18.addAssets)(cdpNftVal, mkLovelacesOf(collateralAmount))
   ).pay.ToContract(
     cdpCreatorUtxo.address,
-    { kind: "inline", value: import_lucid17.Data.void() },
+    { kind: "inline", value: import_lucid18.Data.void() },
     cdpCreatorUtxo.assets
   ).readFrom([priceOracleUtxo, interestOracleUtxo, iassetUtxo]).addSignerKey(pkh.hash);
   const debtMintingFee = calculateFeeFromPercentage(
@@ -1570,7 +1616,7 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
 }
 async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid17.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -1645,7 +1691,7 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
         }
       })
     },
-    (0, import_lucid17.addAssets)(cdpUtxo.assets, mkLovelacesOf(collateralAmount))
+    (0, import_lucid18.addAssets)(cdpUtxo.assets, mkLovelacesOf(collateralAmount))
   );
   if (!cdpDatum.cdpOwner) {
     throw new Error("Expected active CDP");
@@ -1669,7 +1715,7 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
     );
     tx.readFrom([iAssetTokenPolicyRefScriptUtxo]).mintAssets(
       iassetTokensVal,
-      import_lucid17.Data.void()
+      import_lucid18.Data.void()
     );
   }
   const interestAdaAmt = (0, import_ts_pattern7.match)(cdpDatum.cdpFees).with({ FrozenCDPAccumulatedFees: import_ts_pattern7.P.any }, () => {
@@ -1782,7 +1828,7 @@ async function burnCdp(amount, cdpOref, iassetOref, priceOracleOref, interestOra
 }
 async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid17.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -1854,10 +1900,10 @@ async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref
       },
       -cdpDatum.mintedAmt
     ),
-    import_lucid17.Data.void()
+    import_lucid18.Data.void()
   ).mintAssets(
     mkAssetsOf(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken), -1n),
-    import_lucid17.Data.void()
+    import_lucid18.Data.void()
   ).collectFrom(
     [cdpUtxo],
     serialiseCdpRedeemer({ CloseCdp: { currentTime } })
@@ -1903,7 +1949,7 @@ async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref
 }
 async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, treasuryOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid17.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -2012,7 +2058,7 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
       },
       -redemptionIAssetAmt
     ),
-    import_lucid17.Data.void()
+    import_lucid18.Data.void()
   ).pay.ToContract(
     cdpUtxo.address,
     {
@@ -2031,7 +2077,7 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
         }
       })
     },
-    (0, import_lucid17.addAssets)(
+    (0, import_lucid18.addAssets)(
       cdpUtxo.assets,
       mkLovelacesOf(-redemptionLovelacesAmt),
       mkLovelacesOf(reimburstmentFee),
@@ -2056,7 +2102,7 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
 }
 async function freezeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid17.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -2222,7 +2268,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
     stabilityPoolRefScriptUtxo,
     iAssetTokenPolicyRefScriptUtxo,
     cdpAuthTokenPolicyRefScriptUtxo
-  ]).collectFrom([spUtxo], serialiseStabilityPoolRedeemer("LiquidateCDP")).collectFrom([cdpUtxo], serialiseCdpRedeemer("Liquidate")).mintAssets(mkAssetsOf(iassetsAc, -iassetBurnAmt), import_lucid17.Data.void()).pay.ToContract(
+  ]).collectFrom([spUtxo], serialiseStabilityPoolRedeemer("LiquidateCDP")).collectFrom([cdpUtxo], serialiseCdpRedeemer("Liquidate")).mintAssets(mkAssetsOf(iassetsAc, -iassetBurnAmt), import_lucid18.Data.void()).pay.ToContract(
     spUtxo.address,
     {
       kind: "inline",
@@ -2234,7 +2280,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
         ).newSpContent
       })
     },
-    (0, import_lucid17.addAssets)(
+    (0, import_lucid18.addAssets)(
       spUtxo.assets,
       mkLovelacesOf(collateralAbsorbed),
       mkAssetsOf(iassetsAc, -iassetBurnAmt)
@@ -2256,7 +2302,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
           }
         })
       },
-      (0, import_lucid17.addAssets)(
+      (0, import_lucid18.addAssets)(
         mkAssetsOf(cdpNftAc, assetClassValueOf(cdpUtxo.assets, cdpNftAc)),
         mkLovelacesOf(collateralAvailable - collateralAbsorbed)
       )
@@ -2264,7 +2310,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
   } else {
     tx.mintAssets(
       mkAssetsOf(cdpNftAc, -assetClassValueOf(cdpUtxo.assets, cdpNftAc)),
-      import_lucid17.Data.void()
+      import_lucid18.Data.void()
     );
   }
   await collectorFeeTx(
@@ -2291,17 +2337,17 @@ async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
   if (cdpUtxos.length !== cdpsToMergeUtxos.length) {
     throw new Error("Expected certain number of CDPs");
   }
-  const aggregatedVal = import_fp_ts3.function.pipe(
+  const aggregatedVal = import_fp_ts4.function.pipe(
     cdpUtxos,
-    import_fp_ts3.array.reduce({}, (acc, utxo) => (0, import_lucid17.addAssets)(acc, utxo.assets))
+    import_fp_ts4.array.reduce({}, (acc, utxo) => (0, import_lucid18.addAssets)(acc, utxo.assets))
   );
-  const aggregatedMintedAmt = import_fp_ts3.function.pipe(
+  const aggregatedMintedAmt = import_fp_ts4.function.pipe(
     cdpDatums,
-    import_fp_ts3.array.reduce(0n, (acc, cdpDat) => acc + cdpDat.mintedAmt)
+    import_fp_ts4.array.reduce(0n, (acc, cdpDat) => acc + cdpDat.mintedAmt)
   );
-  const { aggregatedFeeTreasury, aggregatedFeeIndyStakers } = import_fp_ts3.function.pipe(
+  const { aggregatedFeeTreasury, aggregatedFeeIndyStakers } = import_fp_ts4.function.pipe(
     cdpDatums,
-    import_fp_ts3.array.reduce(
+    import_fp_ts4.array.reduce(
       { aggregatedFeeIndyStakers: 0n, aggregatedFeeTreasury: 0n },
       (acc, cdpDat) => (0, import_ts_pattern7.match)(cdpDat.cdpFees).returnType().with({ FrozenCDPAccumulatedFees: import_ts_pattern7.P.select() }, (fees) => ({
         aggregatedFeeIndyStakers: acc.aggregatedFeeIndyStakers + fees.lovelacesIndyStakers,
@@ -2310,7 +2356,7 @@ async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
     )
   );
   const [[mainMergeUtxo, mainCdpDatum], otherMergeUtxos] = (0, import_ts_pattern7.match)(
-    import_fp_ts3.array.zip(cdpUtxos, cdpDatums)
+    import_fp_ts4.array.zip(cdpUtxos, cdpDatums)
   ).returnType().with([import_ts_pattern7.P._, ...import_ts_pattern7.P.array()], ([main, ...other]) => [
     main,
     other.map((a) => a[0])
@@ -2348,7 +2394,7 @@ async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
 }
 
 // src/contracts/cdp/scripts.ts
-var import_lucid18 = require("@lucid-evolution/lucid");
+var import_lucid19 = require("@lucid-evolution/lucid");
 
 // src/validators/cdp-validator.ts
 var _cdpValidator = {
@@ -2361,7 +2407,7 @@ var _cdpValidator = {
 var mkCdpValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid18.applyParamsToScript)(_cdpValidator.cborHex, [
+    script: (0, import_lucid19.applyParamsToScript)(_cdpValidator.cborHex, [
       castCdpParams({
         cdp_auth_token: fromSystemParamsAsset(params.cdpAuthToken),
         cdp_asset_symbol: params.cdpAssetSymbol.unCurrencySymbol,
@@ -2386,7 +2432,7 @@ var mkCdpValidatorFromSP = (params) => {
 };
 
 // src/contracts/cdp-creator/scripts.ts
-var import_lucid19 = require("@lucid-evolution/lucid");
+var import_lucid20 = require("@lucid-evolution/lucid");
 
 // src/validators/cdp-creator-validator.ts
 var _cdpCreatorValidator = {
@@ -2399,7 +2445,7 @@ var _cdpCreatorValidator = {
 var mkCDPCreatorValidator = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid19.applyParamsToScript)(_cdpCreatorValidator.cborHex, [
+    script: (0, import_lucid20.applyParamsToScript)(_cdpCreatorValidator.cborHex, [
       castCDPCreatorParams(params)
     ])
   };
@@ -2407,7 +2453,7 @@ var mkCDPCreatorValidator = (params) => {
 var mkCDPCreatorValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid19.applyParamsToScript)(_cdpCreatorValidator.cborHex, [
+    script: (0, import_lucid20.applyParamsToScript)(_cdpCreatorValidator.cborHex, [
       castCDPCreatorParams({
         cdpCreatorNft: fromSystemParamsAsset(params.cdpCreatorNft),
         cdpAssetCs: params.cdpAssetCs.unCurrencySymbol,
@@ -2424,64 +2470,64 @@ var mkCDPCreatorValidatorFromSP = (params) => {
 };
 
 // src/contracts/poll/scripts.ts
-var import_lucid22 = require("@lucid-evolution/lucid");
+var import_lucid23 = require("@lucid-evolution/lucid");
 
 // src/contracts/poll/types-poll-manager.ts
-var import_lucid20 = require("@lucid-evolution/lucid");
-var PollManagerParamsSchema = import_lucid20.Data.Object({
+var import_lucid21 = require("@lucid-evolution/lucid");
+var PollManagerParamsSchema = import_lucid21.Data.Object({
   govNFT: AssetClassSchema,
   pollToken: AssetClassSchema,
   upgradeToken: AssetClassSchema,
   indyAsset: AssetClassSchema,
-  govExecuteValHash: import_lucid20.Data.Bytes(),
-  pBiasTime: import_lucid20.Data.Integer(),
-  shardValHash: import_lucid20.Data.Bytes(),
-  treasuryValHash: import_lucid20.Data.Bytes(),
-  initialIndyDistribution: import_lucid20.Data.Integer()
+  govExecuteValHash: import_lucid21.Data.Bytes(),
+  pBiasTime: import_lucid21.Data.Integer(),
+  shardValHash: import_lucid21.Data.Bytes(),
+  treasuryValHash: import_lucid21.Data.Bytes(),
+  initialIndyDistribution: import_lucid21.Data.Integer()
 });
 var PollManagerParams = PollManagerParamsSchema;
-var PollManagerRedeemerSchema = import_lucid20.Data.Enum([
-  import_lucid20.Data.Object({
-    EndPoll: import_lucid20.Data.Object({ currentTime: import_lucid20.Data.Integer() })
+var PollManagerRedeemerSchema = import_lucid21.Data.Enum([
+  import_lucid21.Data.Object({
+    EndPoll: import_lucid21.Data.Object({ currentTime: import_lucid21.Data.Integer() })
   }),
-  import_lucid20.Data.Object({ CreateShards: import_lucid20.Data.Object({ currentTime: import_lucid20.Data.Integer() }) }),
-  import_lucid20.Data.Object({
-    MergeShardsManager: import_lucid20.Data.Object({ currentTime: import_lucid20.Data.Integer() })
+  import_lucid21.Data.Object({ CreateShards: import_lucid21.Data.Object({ currentTime: import_lucid21.Data.Integer() }) }),
+  import_lucid21.Data.Object({
+    MergeShardsManager: import_lucid21.Data.Object({ currentTime: import_lucid21.Data.Integer() })
   })
 ]);
 var PollManagerRedeemer = PollManagerRedeemerSchema;
 function serialisePollManagerRedeemer(r) {
-  return import_lucid20.Data.to(r, PollManagerRedeemer);
+  return import_lucid21.Data.to(r, PollManagerRedeemer);
 }
 function castPollManagerParams(params) {
-  return import_lucid20.Data.castTo(params, PollManagerParams);
+  return import_lucid21.Data.castTo(params, PollManagerParams);
 }
 
 // src/contracts/poll/types-poll-shard.ts
-var import_lucid21 = require("@lucid-evolution/lucid");
-var PollShardParamsSchema = import_lucid21.Data.Object({
+var import_lucid22 = require("@lucid-evolution/lucid");
+var PollShardParamsSchema = import_lucid22.Data.Object({
   pollToken: AssetClassSchema,
   stakingToken: AssetClassSchema,
   indyAsset: AssetClassSchema,
-  stakingValHash: import_lucid21.Data.Bytes()
+  stakingValHash: import_lucid22.Data.Bytes()
 });
 var PollShardParams = PollShardParamsSchema;
-var VoteOptionSchema = import_lucid21.Data.Enum([import_lucid21.Data.Literal("Yes"), import_lucid21.Data.Literal("No")]);
-var PollShardRedeemerSchema = import_lucid21.Data.Enum([
-  import_lucid21.Data.Object({ Vote: import_lucid21.Data.Object({ content: VoteOptionSchema }) }),
-  import_lucid21.Data.Object({
-    MergeShards: import_lucid21.Data.Object({
-      currentTime: import_lucid21.Data.Integer(),
+var VoteOptionSchema = import_lucid22.Data.Enum([import_lucid22.Data.Literal("Yes"), import_lucid22.Data.Literal("No")]);
+var PollShardRedeemerSchema = import_lucid22.Data.Enum([
+  import_lucid22.Data.Object({ Vote: import_lucid22.Data.Object({ content: VoteOptionSchema }) }),
+  import_lucid22.Data.Object({
+    MergeShards: import_lucid22.Data.Object({
+      currentTime: import_lucid22.Data.Integer(),
       pollManagerRef: OutputReferenceSchema
     })
   })
 ]);
 var PollShardRedeemer = PollShardRedeemerSchema;
 function serialisePollShardRedeemer(redeemer) {
-  return import_lucid21.Data.to(redeemer, PollShardRedeemer);
+  return import_lucid22.Data.to(redeemer, PollShardRedeemer);
 }
 function castPollShardParams(params) {
-  return import_lucid21.Data.castTo(params, PollShardParams);
+  return import_lucid22.Data.castTo(params, PollShardParams);
 }
 
 // src/validators/poll-manager-validator.ts
@@ -2502,7 +2548,7 @@ var _pollShardValidator = {
 var mkPollManagerValidator = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid22.applyParamsToScript)(_pollManagerValidator.cborHex, [
+    script: (0, import_lucid23.applyParamsToScript)(_pollManagerValidator.cborHex, [
       castPollManagerParams(params)
     ])
   };
@@ -2510,7 +2556,7 @@ var mkPollManagerValidator = (params) => {
 var mkPollManagerValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid22.applyParamsToScript)(_pollManagerValidator.cborHex, [
+    script: (0, import_lucid23.applyParamsToScript)(_pollManagerValidator.cborHex, [
       castPollManagerParams({
         govNFT: fromSystemParamsAsset(params.govNFT),
         pollToken: fromSystemParamsAsset(params.pollToken),
@@ -2528,7 +2574,7 @@ var mkPollManagerValidatorFromSP = (params) => {
 var mkPollShardValidator = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid22.applyParamsToScript)(_pollShardValidator.cborHex, [
+    script: (0, import_lucid23.applyParamsToScript)(_pollShardValidator.cborHex, [
       castPollShardParams(params)
     ])
   };
@@ -2536,7 +2582,7 @@ var mkPollShardValidator = (params) => {
 var mkPollShardValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid22.applyParamsToScript)(_pollShardValidator.cborHex, [
+    script: (0, import_lucid23.applyParamsToScript)(_pollShardValidator.cborHex, [
       castPollShardParams({
         pollToken: fromSystemParamsAsset(params.pollToken),
         stakingToken: fromSystemParamsAsset(params.stakingToken),
@@ -2548,119 +2594,123 @@ var mkPollShardValidatorFromSP = (params) => {
 };
 
 // src/contracts/gov/transactions.ts
-var import_lucid29 = require("@lucid-evolution/lucid");
+var import_lucid30 = require("@lucid-evolution/lucid");
 
 // src/contracts/poll/types-poll.ts
-var import_lucid23 = require("@lucid-evolution/lucid");
-var import_fp_ts4 = require("fp-ts");
+var import_lucid24 = require("@lucid-evolution/lucid");
+var import_fp_ts5 = require("fp-ts");
 var import_ts_pattern8 = require("ts-pattern");
-var PollStatusSchema = import_lucid23.Data.Object({
-  yesVotes: import_lucid23.Data.Integer(),
-  noVotes: import_lucid23.Data.Integer()
+var PollStatusSchema = import_lucid24.Data.Object({
+  yesVotes: import_lucid24.Data.Integer(),
+  noVotes: import_lucid24.Data.Integer()
 });
-var PollManagerContentSchema = import_lucid23.Data.Object({
-  pollId: import_lucid23.Data.Integer(),
-  pollOwner: import_lucid23.Data.Bytes(),
+var PollManagerContentSchema = import_lucid24.Data.Object({
+  pollId: import_lucid24.Data.Integer(),
+  pollOwner: import_lucid24.Data.Bytes(),
   content: ProposalContentSchema,
-  treasuryWithdrawal: import_lucid23.Data.Nullable(TreasuryWithdrawalSchema),
+  treasuryWithdrawal: import_lucid24.Data.Nullable(TreasuryWithdrawalSchema),
   status: PollStatusSchema,
-  votingEndTime: import_lucid23.Data.Integer(),
-  createdShardsCount: import_lucid23.Data.Integer(),
-  talliedShardsCount: import_lucid23.Data.Integer(),
-  totalShardsCount: import_lucid23.Data.Integer(),
-  proposingEndTime: import_lucid23.Data.Integer(),
-  expirationTime: import_lucid23.Data.Integer(),
-  protocolVersion: import_lucid23.Data.Integer(),
-  minimumQuorum: import_lucid23.Data.Integer()
+  votingEndTime: import_lucid24.Data.Integer(),
+  createdShardsCount: import_lucid24.Data.Integer(),
+  talliedShardsCount: import_lucid24.Data.Integer(),
+  totalShardsCount: import_lucid24.Data.Integer(),
+  proposingEndTime: import_lucid24.Data.Integer(),
+  expirationTime: import_lucid24.Data.Integer(),
+  protocolVersion: import_lucid24.Data.Integer(),
+  minimumQuorum: import_lucid24.Data.Integer()
 });
-var PollShardContentSchema = import_lucid23.Data.Object({
-  pollId: import_lucid23.Data.Integer(),
+var PollShardContentSchema = import_lucid24.Data.Object({
+  pollId: import_lucid24.Data.Integer(),
   status: PollStatusSchema,
-  votingEndTime: import_lucid23.Data.Integer(),
+  votingEndTime: import_lucid24.Data.Integer(),
   managerAddress: AddressSchema
 });
-var PollDatumSchema = import_lucid23.Data.Enum([
-  import_lucid23.Data.Object({
-    PollManager: import_lucid23.Data.Object({ content: PollManagerContentSchema })
+var PollDatumSchema = import_lucid24.Data.Enum([
+  import_lucid24.Data.Object({
+    PollManager: import_lucid24.Data.Object({ content: PollManagerContentSchema })
   }),
-  import_lucid23.Data.Object({ PollShard: import_lucid23.Data.Object({ content: PollShardContentSchema }) })
+  import_lucid24.Data.Object({ PollShard: import_lucid24.Data.Object({ content: PollShardContentSchema }) })
 ]);
 var PollDatum = PollDatumSchema;
 function parsePollManager(datum) {
   try {
-    return (0, import_ts_pattern8.match)(import_lucid23.Data.from(datum, PollDatum)).with({ PollManager: import_ts_pattern8.P.select() }, (res) => import_fp_ts4.option.some(res.content)).otherwise(() => import_fp_ts4.option.none);
+    return (0, import_ts_pattern8.match)(import_lucid24.Data.from(datum, PollDatum)).with({ PollManager: import_ts_pattern8.P.select() }, (res) => import_fp_ts5.option.some(res.content)).otherwise(() => import_fp_ts5.option.none);
   } catch (_) {
-    return import_fp_ts4.option.none;
+    return import_fp_ts5.option.none;
   }
 }
 function parsePollManagerOrThrow(datum) {
-  return import_fp_ts4.function.pipe(
+  return import_fp_ts5.function.pipe(
     parsePollManager(datum),
-    import_fp_ts4.option.match(() => {
+    import_fp_ts5.option.match(() => {
       throw new Error("Expected a Poll manager datum.");
-    }, import_fp_ts4.function.identity)
+    }, import_fp_ts5.function.identity)
   );
 }
 function parsePollShard(datum) {
   try {
-    return (0, import_ts_pattern8.match)(import_lucid23.Data.from(datum, PollDatum)).with({ PollShard: import_ts_pattern8.P.select() }, (res) => import_fp_ts4.option.some(res.content)).otherwise(() => import_fp_ts4.option.none);
+    return (0, import_ts_pattern8.match)(import_lucid24.Data.from(datum, PollDatum)).with({ PollShard: import_ts_pattern8.P.select() }, (res) => import_fp_ts5.option.some(res.content)).otherwise(() => import_fp_ts5.option.none);
   } catch (_) {
-    return import_fp_ts4.option.none;
+    return import_fp_ts5.option.none;
   }
 }
 function parsePollShardOrThrow(datum) {
-  return import_fp_ts4.function.pipe(
+  return import_fp_ts5.function.pipe(
     parsePollShard(datum),
-    import_fp_ts4.option.match(() => {
+    import_fp_ts5.option.match(() => {
       throw new Error("Expected a Poll shard datum.");
-    }, import_fp_ts4.function.identity)
+    }, import_fp_ts5.function.identity)
   );
 }
 function serialisePollDatum(datum) {
-  return import_lucid23.Data.to(datum, PollDatum);
+  return import_lucid24.Data.to(datum, PollDatum);
 }
 
 // src/contracts/gov/transactions.ts
-var import_lucid30 = require("@lucid-evolution/lucid");
+var import_lucid31 = require("@lucid-evolution/lucid");
 var import_function2 = require("fp-ts/lib/function");
-var import_fp_ts9 = require("fp-ts");
+var import_fp_ts10 = require("fp-ts");
 var import_ts_pattern11 = require("ts-pattern");
 
 // src/contracts/staking/types.ts
-var import_lucid24 = require("@lucid-evolution/lucid");
-var StakingParamsSchema = import_lucid24.Data.Object({
+var import_lucid25 = require("@lucid-evolution/lucid");
+var StakingParamsSchema = import_lucid25.Data.Object({
   stakingManagerNft: AssetClassSchema,
   stakingToken: AssetClassSchema,
   indyToken: AssetClassSchema,
   pollToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  collectorValHash: import_lucid24.Data.Bytes()
+  collectorValHash: import_lucid25.Data.Bytes()
 });
-var StakingRedeemerSchema = import_lucid24.Data.Enum([
-  import_lucid24.Data.Object({
-    CreateStakingPosition: import_lucid24.Data.Object({
-      creatorPkh: import_lucid24.Data.Bytes()
+var StakingParams = StakingParamsSchema;
+var StakingRedeemerSchema = import_lucid25.Data.Enum([
+  import_lucid25.Data.Object({
+    CreateStakingPosition: import_lucid25.Data.Object({
+      creatorPkh: import_lucid25.Data.Bytes()
     })
   }),
-  import_lucid24.Data.Literal("UpdateTotalStake"),
-  import_lucid24.Data.Literal("Distribute"),
-  import_lucid24.Data.Object({
-    AdjustStakedAmount: import_lucid24.Data.Object({
-      adjustAmount: import_lucid24.Data.Integer()
+  import_lucid25.Data.Literal("UpdateTotalStake"),
+  import_lucid25.Data.Literal("Distribute"),
+  import_lucid25.Data.Object({
+    AdjustStakedAmount: import_lucid25.Data.Object({
+      adjustAmount: import_lucid25.Data.Integer()
     })
   }),
-  import_lucid24.Data.Literal("Unstake"),
-  import_lucid24.Data.Literal("Lock"),
-  import_lucid24.Data.Literal("UpgradeVersion")
+  import_lucid25.Data.Literal("Unstake"),
+  import_lucid25.Data.Literal("Lock"),
+  import_lucid25.Data.Literal("UpgradeVersion")
 ]);
 var StakingRedeemer = StakingRedeemerSchema;
 function serialiseStakingRedeemer(redeemer) {
-  return import_lucid24.Data.to(redeemer, StakingRedeemer);
+  return import_lucid25.Data.to(redeemer, StakingRedeemer);
+}
+function castStakingParams(params) {
+  return import_lucid25.Data.castTo(params, StakingParams);
 }
 
 // src/contracts/staking/types-new.ts
 var import_evolution3 = require("@evolution-sdk/evolution");
-var import_fp_ts5 = require("fp-ts");
+var import_fp_ts6 = require("fp-ts");
 var import_ts_pattern9 = require("ts-pattern");
 var StakingPosLockedAmtSchema = import_evolution3.Core.TSchema.Map(
   import_evolution3.Core.TSchema.Integer,
@@ -2692,17 +2742,17 @@ function parseStakingPosition(datum) {
         StakingDatumSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(datum)
-    ).with({ owner: import_ts_pattern9.P.any }, (res) => import_fp_ts5.option.some(res)).otherwise(() => import_fp_ts5.option.none);
+    ).with({ owner: import_ts_pattern9.P.any }, (res) => import_fp_ts6.option.some(res)).otherwise(() => import_fp_ts6.option.none);
   } catch (_) {
-    return import_fp_ts5.option.none;
+    return import_fp_ts6.option.none;
   }
 }
 function parseStakingPositionOrThrow(datum) {
-  return import_fp_ts5.function.pipe(
+  return import_fp_ts6.function.pipe(
     parseStakingPosition(datum),
-    import_fp_ts5.option.match(() => {
+    import_fp_ts6.option.match(() => {
       throw new Error("Expected a StakingPosition datum.");
-    }, import_fp_ts5.function.identity)
+    }, import_fp_ts6.function.identity)
   );
 }
 function parseStakingManagerDatum(datum) {
@@ -2723,10 +2773,10 @@ function serialiseStakingDatum(d) {
 }
 
 // src/contracts/staking/helpers.ts
-var import_lucid26 = require("@lucid-evolution/lucid");
+var import_lucid27 = require("@lucid-evolution/lucid");
 
 // src/contracts/staking/scripts.ts
-var import_lucid25 = require("@lucid-evolution/lucid");
+var import_lucid26 = require("@lucid-evolution/lucid");
 
 // src/validators/staking-validator.ts
 var _stakingValidator = {
@@ -2739,27 +2789,27 @@ var _stakingValidator = {
 var mkStakingValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid25.applyParamsToScript)(_stakingValidator.cborHex, [
-      new import_lucid25.Constr(0, [
-        new import_lucid25.Constr(0, [
+    script: (0, import_lucid26.applyParamsToScript)(_stakingValidator.cborHex, [
+      new import_lucid26.Constr(0, [
+        new import_lucid26.Constr(0, [
           params.stakingManagerNFT[0].unCurrencySymbol,
-          (0, import_lucid25.fromText)(params.stakingManagerNFT[1].unTokenName)
+          (0, import_lucid26.fromText)(params.stakingManagerNFT[1].unTokenName)
         ]),
-        new import_lucid25.Constr(0, [
+        new import_lucid26.Constr(0, [
           params.stakingToken[0].unCurrencySymbol,
-          (0, import_lucid25.fromText)(params.stakingToken[1].unTokenName)
+          (0, import_lucid26.fromText)(params.stakingToken[1].unTokenName)
         ]),
-        new import_lucid25.Constr(0, [
+        new import_lucid26.Constr(0, [
           params.indyToken[0].unCurrencySymbol,
-          (0, import_lucid25.fromText)(params.indyToken[1].unTokenName)
+          (0, import_lucid26.fromText)(params.indyToken[1].unTokenName)
         ]),
-        new import_lucid25.Constr(0, [
+        new import_lucid26.Constr(0, [
           params.pollToken[0].unCurrencySymbol,
-          (0, import_lucid25.fromText)(params.pollToken[1].unTokenName)
+          (0, import_lucid26.fromText)(params.pollToken[1].unTokenName)
         ]),
-        new import_lucid25.Constr(0, [
+        new import_lucid26.Constr(0, [
           params.versionRecordToken[0].unCurrencySymbol,
-          (0, import_lucid25.fromText)(params.versionRecordToken[1].unTokenName)
+          (0, import_lucid26.fromText)(params.versionRecordToken[1].unTokenName)
         ]),
         params.collectorValHash
       ])
@@ -2792,9 +2842,9 @@ function findStakingManager(params, lucid) {
   return lucid.utxosAtWithUnit(
     createScriptAddress(
       lucid.config().network,
-      (0, import_lucid26.validatorToScriptHash)(mkStakingValidatorFromSP(params.stakingParams))
+      (0, import_lucid27.validatorToScriptHash)(mkStakingValidatorFromSP(params.stakingParams))
     ),
-    params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid26.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName)
+    params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid27.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName)
   ).then(
     (utxos) => utxos.map((utxo) => {
       if (!utxo.datum) return void 0;
@@ -2824,10 +2874,14 @@ function findStakingPositionByOutRef(stakingPositionRef, lucid) {
     return result;
   });
 }
+var rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;
+function distributeReward(snapshotAda, adaReward, totalStake) {
+  return snapshotAda + adaReward * rewardSnapshotPrecision / totalStake;
+}
 
 // src/contracts/vesting/helpers.ts
 var import_ts_pattern10 = require("ts-pattern");
-var import_fp_ts6 = require("fp-ts");
+var import_fp_ts7 = require("fp-ts");
 var teamVestingSchedule = [
   {
     vestedAtTime: 1669067100000n,
@@ -3014,7 +3068,7 @@ var govDistributionSchedule = {
   ]
 };
 function calculateTotalVestedTeam(currentTime) {
-  return import_fp_ts6.array.reduce(0n, (acc, schedule) => {
+  return import_fp_ts7.array.reduce(0n, (acc, schedule) => {
     if (currentTime >= schedule.vestedAtTime) {
       return acc + schedule.unlockAmt;
     } else {
@@ -3072,64 +3126,64 @@ function pollPassQuorum(initialIndyDist, pollStatus, currentTime, minQuorum, tre
 }
 
 // src/contracts/execute/types.ts
-var import_lucid27 = require("@lucid-evolution/lucid");
-var import_fp_ts7 = require("fp-ts");
-var ExecuteParamsSchema = import_lucid27.Data.Object({
+var import_lucid28 = require("@lucid-evolution/lucid");
+var import_fp_ts8 = require("fp-ts");
+var ExecuteParamsSchema = import_lucid28.Data.Object({
   govNFT: AssetClassSchema,
   upgradeToken: AssetClassSchema,
   iAssetToken: AssetClassSchema,
   stabilityPoolToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  cdpValHash: import_lucid27.Data.Bytes(),
-  sPoolValHash: import_lucid27.Data.Bytes(),
-  versionRegistryValHash: import_lucid27.Data.Bytes(),
-  treasuryValHash: import_lucid27.Data.Bytes(),
+  cdpValHash: import_lucid28.Data.Bytes(),
+  sPoolValHash: import_lucid28.Data.Bytes(),
+  versionRegistryValHash: import_lucid28.Data.Bytes(),
+  treasuryValHash: import_lucid28.Data.Bytes(),
   indyAsset: AssetClassSchema
 });
 var ExecuteParams = ExecuteParamsSchema;
-var ExecuteDatumSchema = import_lucid27.Data.Object({
-  id: import_lucid27.Data.Integer(),
+var ExecuteDatumSchema = import_lucid28.Data.Object({
+  id: import_lucid28.Data.Integer(),
   content: ProposalContentSchema,
-  passedTime: import_lucid27.Data.Integer(),
-  votingEndTime: import_lucid27.Data.Integer(),
-  protocolVersion: import_lucid27.Data.Integer(),
+  passedTime: import_lucid28.Data.Integer(),
+  votingEndTime: import_lucid28.Data.Integer(),
+  protocolVersion: import_lucid28.Data.Integer(),
   /// Value proposed to be withdrawn from the treasury as part of the proposal.
-  treasuryWithdrawal: import_lucid27.Data.Nullable(TreasuryWithdrawalSchema)
+  treasuryWithdrawal: import_lucid28.Data.Nullable(TreasuryWithdrawalSchema)
 });
 var ExecuteDatum = ExecuteDatumSchema;
 function serialiseExecuteDatum(d) {
-  return import_lucid27.Data.to(d, ExecuteDatum);
+  return import_lucid28.Data.to(d, ExecuteDatum);
 }
 function parseExecuteDatum(d) {
   try {
-    return import_fp_ts7.option.some(import_lucid27.Data.from(d, ExecuteDatum));
+    return import_fp_ts8.option.some(import_lucid28.Data.from(d, ExecuteDatum));
   } catch (_) {
-    return import_fp_ts7.option.none;
+    return import_fp_ts8.option.none;
   }
 }
 function parseExecuteDatumOrThrow(d) {
-  return import_fp_ts7.function.pipe(
+  return import_fp_ts8.function.pipe(
     parseExecuteDatum(d),
-    import_fp_ts7.option.match(() => {
+    import_fp_ts8.option.match(() => {
       throw new Error("Expected an Execute datum.");
-    }, import_fp_ts7.function.identity)
+    }, import_fp_ts8.function.identity)
   );
 }
 function castExecuteParams(params) {
-  return import_lucid27.Data.castTo(params, ExecuteParams);
+  return import_lucid28.Data.castTo(params, ExecuteParams);
 }
 
 // src/contracts/gov/helpers.ts
 var import_function = require("fp-ts/lib/function");
-var import_fp_ts8 = require("fp-ts");
-var import_lucid28 = require("@lucid-evolution/lucid");
+var import_fp_ts9 = require("fp-ts");
+var import_lucid29 = require("@lucid-evolution/lucid");
 function proposalDeposit(baseDeposit, activeProposals) {
   return baseDeposit * 2n ** activeProposals;
 }
 function createValueFromWithdrawal(w) {
-  return import_fp_ts8.array.reduce(
+  return import_fp_ts9.array.reduce(
     {},
-    (acc, [cs, tk, amt]) => (0, import_lucid28.addAssets)(acc, mkAssetsOf({ currencySymbol: cs, tokenName: tk }, amt))
+    (acc, [cs, tk, amt]) => (0, import_lucid29.addAssets)(acc, mkAssetsOf({ currencySymbol: cs, tokenName: tk }, amt))
   )(w.value);
 }
 async function findRelativeIAssetForInsertion(newIAssetTokenName, allIAssetOrefs, lucid) {
@@ -3146,22 +3200,22 @@ async function findRelativeIAssetForInsertion(newIAssetTokenName, allIAssetOrefs
   return (0, import_function.pipe)(
     // Sort the asset names
     iassetUtxos,
-    import_fp_ts8.array.sort(
-      import_fp_ts8.ord.contramap((x) => (0, import_lucid28.toText)(x.datum.assetName))(
-        import_fp_ts8.string.Ord
+    import_fp_ts9.array.sort(
+      import_fp_ts9.ord.contramap((x) => (0, import_lucid29.toText)(x.datum.assetName))(
+        import_fp_ts9.string.Ord
       )
     ),
     // split head and tail
-    import_fp_ts8.array.foldLeft(
-      () => import_fp_ts8.option.none,
-      (head, rest) => import_fp_ts8.option.some([head, rest])
+    import_fp_ts9.array.foldLeft(
+      () => import_fp_ts9.option.none,
+      (head, rest) => import_fp_ts9.option.some([head, rest])
     ),
     // find the preceding iasset for the new token name
-    import_fp_ts8.option.flatMap(
-      ([firstIAsset, rest]) => import_fp_ts8.option.some(
-        import_fp_ts8.array.reduce(
+    import_fp_ts9.option.flatMap(
+      ([firstIAsset, rest]) => import_fp_ts9.option.some(
+        import_fp_ts9.array.reduce(
           firstIAsset,
-          (acc, iasset) => (0, import_lucid28.toText)(iasset.datum.assetName) < newIAssetTokenName ? iasset : acc
+          (acc, iasset) => (0, import_lucid29.toText)(iasset.datum.assetName) < newIAssetTokenName ? iasset : acc
         )(rest)
       )
     )
@@ -3184,22 +3238,22 @@ function iassetCreationDatumHelper(proposeAssetContent, referencedIAsset) {
     firstIAsset: true,
     nextIAsset: null
   };
-  return import_fp_ts8.function.pipe(
+  return import_fp_ts9.function.pipe(
     referencedIAsset,
-    import_fp_ts8.option.match(
+    import_fp_ts9.option.match(
       () => ({
         newIAsset: newContent,
-        newReferencedIAsset: import_fp_ts8.option.none
+        newReferencedIAsset: import_fp_ts9.option.none
       }),
       (referencedIA) => {
-        if ((0, import_lucid28.toText)(proposeAssetContent.asset) < (0, import_lucid28.toText)(referencedIA.assetName)) {
+        if ((0, import_lucid29.toText)(proposeAssetContent.asset) < (0, import_lucid29.toText)(referencedIA.assetName)) {
           return {
             newIAsset: {
               ...newContent,
               firstIAsset: true,
               nextIAsset: referencedIA.assetName
             },
-            newReferencedIAsset: import_fp_ts8.option.some({
+            newReferencedIAsset: import_fp_ts9.option.some({
               ...referencedIA,
               firstIAsset: false
             })
@@ -3211,7 +3265,7 @@ function iassetCreationDatumHelper(proposeAssetContent, referencedIAsset) {
               firstIAsset: false,
               nextIAsset: referencedIA.nextIAsset
             },
-            newReferencedIAsset: import_fp_ts8.option.some({
+            newReferencedIAsset: import_fp_ts9.option.some({
               ...referencedIA,
               nextIAsset: proposeAssetContent.asset
             })
@@ -3242,9 +3296,9 @@ function serialiseVersionRecordDatum(d) {
 // src/contracts/gov/transactions.ts
 async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
-  const pkh = (0, import_lucid29.paymentCredentialOf)(ownAddr);
+  const pkh = (0, import_lucid30.paymentCredentialOf)(ownAddr);
   const govRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -3277,13 +3331,13 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
   const tx = lucid.newTx();
   await (0, import_ts_pattern11.match)(proposalContent).with({ ProposeAsset: { asset: import_ts_pattern11.P.select() } }, async (newAsset) => {
     const relativeIAsset = await findRelativeIAssetForInsertion(
-      (0, import_lucid29.toText)(newAsset),
+      (0, import_lucid30.toText)(newAsset),
       allIAssetOrefs,
       lucid
     );
     (0, import_function2.pipe)(
       relativeIAsset,
-      import_fp_ts9.option.match(
+      import_fp_ts10.option.match(
         () => {
           if (govDatum.iassetsCount !== 0n) {
             throw new Error(
@@ -3299,7 +3353,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
   }).otherwise(() => {
   });
   return [
-    tx.mintAssets(pollNftValue, import_lucid30.Data.void()).readFrom([govRefScriptUtxo, pollAuthTokenPolicyRefScriptUtxo]).collectFrom(
+    tx.mintAssets(pollNftValue, import_lucid31.Data.void()).readFrom([govRefScriptUtxo, pollAuthTokenPolicyRefScriptUtxo]).collectFrom(
       [govUtxo],
       serialiseGovRedeemer({
         CreatePoll: {
@@ -3344,7 +3398,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
           }
         })
       },
-      (0, import_lucid29.addAssets)(
+      (0, import_lucid30.addAssets)(
         pollNftValue,
         mkAssetsOf(
           fromSystemParamsAsset(sysParams.govParams.indyAsset),
@@ -3360,7 +3414,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
 }
 async function createShardsChunks(chunkSize, pollManagerOref, sysParams, currentSlot, lucid) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
   const pollManagerUtxo = matchSingle(
     await lucid.utxosByOutRef([pollManagerOref]),
@@ -3397,7 +3451,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 + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
-  ).mintAssets(mkAssetsOf(pollNft, shardsCount), import_lucid30.Data.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
+  ).mintAssets(mkAssetsOf(pollNft, shardsCount), import_lucid31.Data.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({ CreateShards: { currentTime } })
   ).pay.ToContract(
@@ -3455,7 +3509,7 @@ function voteHelper(stakingPosLockedAmt, pollShard, voteOption, currentTime, ind
 }
 async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
   const pollShardRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -3531,7 +3585,7 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
 }
 async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
   const pollShardRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -3565,10 +3619,10 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     getInlineDatumOrThrow(pollManagerUtxo)
   );
   const shardUtxos = await lucid.utxosByOutRef(shardsOutRefs);
-  const aggregatedStatus = import_fp_ts9.function.pipe(
+  const aggregatedStatus = import_fp_ts10.function.pipe(
     shardUtxos,
-    import_fp_ts9.array.map((utxo) => parsePollShardOrThrow(getInlineDatumOrThrow(utxo))),
-    import_fp_ts9.array.reduce(
+    import_fp_ts10.array.map((utxo) => parsePollShardOrThrow(getInlineDatumOrThrow(utxo))),
+    import_fp_ts10.array.reduce(
       pollManagerDatum.status,
       (acc, shard) => ({
         yesVotes: acc.yesVotes + shard.status.yesVotes,
@@ -3576,9 +3630,9 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
       })
     )
   );
-  const shardsAggregatedAda = import_fp_ts9.array.reduce(
+  const shardsAggregatedAda = import_fp_ts10.array.reduce(
     {},
-    (acc, utxo) => (0, import_lucid29.addAssets)(acc, mkLovelacesOf(lovelacesAmt(utxo.assets)))
+    (acc, utxo) => (0, import_lucid30.addAssets)(acc, mkLovelacesOf(lovelacesAmt(utxo.assets)))
   )(shardUtxos);
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   return lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
@@ -3587,7 +3641,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     pollShardRefScriptUtxo,
     pollManagerRefScriptUtxo,
     pollAuthTokenPolicyRefScriptUtxo
-  ]).mintAssets(mkAssetsOf(pollNft, -BigInt(shardsOutRefs.length)), import_lucid30.Data.void()).collectFrom(
+  ]).mintAssets(mkAssetsOf(pollNft, -BigInt(shardsOutRefs.length)), import_lucid31.Data.void()).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({
       MergeShardsManager: { currentTime }
@@ -3617,12 +3671,12 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
         }
       })
     },
-    (0, import_lucid29.addAssets)(pollManagerUtxo.assets, shardsAggregatedAda)
+    (0, import_lucid30.addAssets)(pollManagerUtxo.assets, shardsAggregatedAda)
   ).addSigner(ownAddr);
 }
 async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
   const pollManagerRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -3697,7 +3751,7 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
   ).collectFrom(
     [govUtxo],
     serialiseGovRedeemer({ WitnessEndPoll: { currentTime } })
-  ).mintAssets(mkAssetsOf(pollNft, -1n), import_lucid30.Data.void()).pay.ToContract(
+  ).mintAssets(mkAssetsOf(pollNft, -1n), import_lucid31.Data.void()).pay.ToContract(
     govUtxo.address,
     {
       kind: "inline",
@@ -3723,11 +3777,11 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
         })
       },
       upgradeTokenVal
-    ).mintAssets(upgradeTokenVal, import_lucid30.Data.void());
+    ).mintAssets(upgradeTokenVal, import_lucid31.Data.void());
   } else {
     tx.pay.ToContract(
       createScriptAddress(network, sysParams.validatorHashes.treasuryHash),
-      { kind: "inline", value: import_lucid30.Data.void() },
+      { kind: "inline", value: import_lucid31.Data.void() },
       mkAssetsOf(
         indyAsset,
         assetClassValueOf(pollManagerUtxo.assets, indyAsset)
@@ -3738,7 +3792,7 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
 }
 async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, allIAssetOrefs, modifyIAssetOref, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
-  const currentTime = BigInt((0, import_lucid29.slotToUnixTime)(network, currentSlot));
+  const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
   const govUtxo = matchSingle(
     await lucid.utxosByOutRef([govOref]),
@@ -3784,8 +3838,8 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
   );
   const tx = lucid.newTx();
   await (0, import_function2.pipe)(
-    import_fp_ts9.option.fromNullable(executeDatum.treasuryWithdrawal),
-    import_fp_ts9.option.match(
+    import_fp_ts10.option.fromNullable(executeDatum.treasuryWithdrawal),
+    import_fp_ts10.option.match(
       () => {
         if (treasuryWithdrawalOref) {
           throw new Error("Cannot provide withdrawal oref when no withdrawal.");
@@ -3809,7 +3863,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
           (_) => new Error("Expected a single withdrawal UTXO")
         );
         const withdrawalVal = createValueFromWithdrawal(withdrawal);
-        const withdrawalChangeVal = (0, import_lucid29.addAssets)(
+        const withdrawalChangeVal = (0, import_lucid30.addAssets)(
           treasuryWithdrawalUtxo.assets,
           negateAssets(withdrawalVal)
         );
@@ -3822,7 +3876,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
                 sysParams.treasuryParams.treasuryUtxosStakeCredential
               ) : void 0
             ),
-            { kind: "inline", value: import_lucid30.Data.void() },
+            { kind: "inline", value: import_lucid31.Data.void() },
             withdrawalChangeVal
           );
         }
@@ -3834,7 +3888,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
           {
             kind: "inline",
             value: serialiseWithdrawalOutputDatum([
-              (0, import_lucid29.fromText)("IndigoTreasuryWithdrawal"),
+              (0, import_lucid30.fromText)("IndigoTreasuryWithdrawal"),
               {
                 txHash: { hash: executeUtxo.txHash },
                 outputIndex: BigInt(executeUtxo.outputIndex)
@@ -3875,15 +3929,15 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       throw new Error("Have to provide all iasset orefs when propose asset.");
     }
     const iassetToReference = await findRelativeIAssetForInsertion(
-      (0, import_lucid29.toText)(proposeContent.asset),
+      (0, import_lucid30.toText)(proposeContent.asset),
       allIAssetOrefs,
       lucid
     );
     const { newIAsset, newReferencedIAsset } = iassetCreationDatumHelper(
       proposeContent,
-      import_fp_ts9.function.pipe(
+      import_fp_ts10.function.pipe(
         iassetToReference,
-        import_fp_ts9.option.map((i) => i.datum)
+        import_fp_ts10.option.map((i) => i.datum)
       )
     );
     const iassetAuthVal = mkAssetsOf(
@@ -3899,7 +3953,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       cdpRefScriptUtxo,
       iassetTokenPolicyRefScriptUtxo,
       stabilityPoolTokenPolicyRefScriptUtxo
-    ]).mintAssets(spAuthVal, import_lucid30.Data.void()).mintAssets(iassetAuthVal, import_lucid30.Data.void()).collectFrom([govUtxo], serialiseGovRedeemer("UpgradeGov")).pay.ToContract(
+    ]).mintAssets(spAuthVal, import_lucid31.Data.void()).mintAssets(iassetAuthVal, import_lucid31.Data.void()).collectFrom([govUtxo], serialiseGovRedeemer("UpgradeGov")).pay.ToContract(
       govUtxo.address,
       {
         kind: "inline",
@@ -3924,7 +3978,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
         value: serialiseStabilityPoolDatum(
           {
             StabilityPool: {
-              asset: (0, import_lucid29.fromHex)(proposeContent.asset),
+              asset: (0, import_lucid30.fromHex)(proposeContent.asset),
               poolSnapshot: initSpSnapshot,
               epochToScaleToSum: initEpochToScaleToSumMap()
             }
@@ -3934,14 +3988,14 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       },
       spAuthVal
     );
-    import_fp_ts9.function.pipe(
+    import_fp_ts10.function.pipe(
       iassetToReference,
-      import_fp_ts9.option.match(
+      import_fp_ts10.option.match(
         () => {
         },
-        (i) => import_fp_ts9.function.pipe(
+        (i) => import_fp_ts10.function.pipe(
           newReferencedIAsset,
-          import_fp_ts9.option.match(
+          import_fp_ts10.option.match(
             () => {
               throw new Error("Expected some referenced iasset.");
             },
@@ -4065,7 +4119,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       fromSystemParamsAsset(sysParams.executeParams.versionRecordToken),
       1n
     );
-    tx.readFrom([govRefScriptUtxo, versionRecordTokenPolicyRefScriptUtxo]).mintAssets(versionRecordNftVal, import_lucid30.Data.void()).pay.ToContract(
+    tx.readFrom([govRefScriptUtxo, versionRecordTokenPolicyRefScriptUtxo]).mintAssets(versionRecordNftVal, import_lucid31.Data.void()).pay.ToContract(
       createScriptAddress(
         network,
         sysParams.validatorHashes.versionRegistryHash
@@ -4093,52 +4147,52 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       govUtxo.assets
     );
   }).exhaustive();
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], import_lucid30.Data.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], import_lucid31.Data.void()).mintAssets(
     mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
-    import_lucid30.Data.void()
+    import_lucid31.Data.void()
   ).addSigner(ownAddr);
   return tx;
 }
 
 // src/contracts/stability-pool/transactions.ts
-var import_lucid33 = require("@lucid-evolution/lucid");
+var import_lucid34 = require("@lucid-evolution/lucid");
 
 // src/contracts/stability-pool/types.ts
-var import_lucid31 = require("@lucid-evolution/lucid");
-var ActionReturnDatumSchema = import_lucid31.Data.Enum([
-  import_lucid31.Data.Object({
-    IndigoStabilityPoolAccountAdjustment: import_lucid31.Data.Object({
+var import_lucid32 = require("@lucid-evolution/lucid");
+var ActionReturnDatumSchema = import_lucid32.Data.Enum([
+  import_lucid32.Data.Object({
+    IndigoStabilityPoolAccountAdjustment: import_lucid32.Data.Object({
       spent_account: OutputReferenceSchema
     })
   }),
-  import_lucid31.Data.Object({
-    IndigoStabilityPoolAccountClosure: import_lucid31.Data.Object({
+  import_lucid32.Data.Object({
+    IndigoStabilityPoolAccountClosure: import_lucid32.Data.Object({
       closed_account: OutputReferenceSchema
     })
   })
 ]);
 var ActionReturnDatum = ActionReturnDatumSchema;
-var StabilityPoolParamsSchema = import_lucid31.Data.Object({
-  assetSymbol: import_lucid31.Data.Bytes(),
+var StabilityPoolParamsSchema = import_lucid32.Data.Object({
+  assetSymbol: import_lucid32.Data.Bytes(),
   stabilityPoolToken: AssetClassSchema,
   snapshotEpochToScaleToSumToken: AssetClassSchema,
   accountToken: AssetClassSchema,
   cdpToken: AssetClassSchema,
   iAssetAuthToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  collectorValHash: import_lucid31.Data.Bytes(),
+  collectorValHash: import_lucid32.Data.Bytes(),
   govNFT: AssetClassSchema,
-  accountCreateFeeLovelaces: import_lucid31.Data.Integer(),
-  accountAdjustmentFeeLovelaces: import_lucid31.Data.Integer(),
-  requestCollateralLovelaces: import_lucid31.Data.Integer()
+  accountCreateFeeLovelaces: import_lucid32.Data.Integer(),
+  accountAdjustmentFeeLovelaces: import_lucid32.Data.Integer(),
+  requestCollateralLovelaces: import_lucid32.Data.Integer()
 });
 var StabilityPoolParams = StabilityPoolParamsSchema;
 function castStabilityPoolParams(params) {
-  return import_lucid31.Data.castTo(params, StabilityPoolParams);
+  return import_lucid32.Data.castTo(params, StabilityPoolParams);
 }
 
 // src/contracts/stability-pool/scripts.ts
-var import_lucid32 = require("@lucid-evolution/lucid");
+var import_lucid33 = require("@lucid-evolution/lucid");
 
 // src/validators/stability-pool-validator.ts
 var _stabilityPoolValidator = {
@@ -4151,7 +4205,7 @@ var _stabilityPoolValidator = {
 var mkStabilityPoolValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid32.applyParamsToScript)(_stabilityPoolValidator.cborHex, [
+    script: (0, import_lucid33.applyParamsToScript)(_stabilityPoolValidator.cborHex, [
       castStabilityPoolParams({
         assetSymbol: params.assetSymbol.unCurrencySymbol,
         stabilityPoolToken: fromSystemParamsAsset(params.stabilityPoolToken),
@@ -4182,8 +4236,8 @@ async function createSpAccount(asset, amount, params, lucid) {
     params.stabilityPoolParams.accountCreateFeeLovelaces + params.stabilityPoolParams.requestCollateralLovelaces
   );
   const datum = {
-    owner: (0, import_lucid33.fromHex)(pkh.hash),
-    asset: (0, import_lucid33.fromHex)((0, import_lucid33.fromText)(asset)),
+    owner: (0, import_lucid34.fromHex)(pkh.hash),
+    asset: (0, import_lucid34.fromHex)((0, import_lucid34.fromText)(asset)),
     accountSnapshot: {
       productVal: { value: 0n },
       depositVal: { value: 0n },
@@ -4194,8 +4248,8 @@ async function createSpAccount(asset, amount, params, lucid) {
     request: "Create"
   };
   return lucid.newTx().pay.ToContract(
-    (0, import_lucid33.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid33.validatorToScriptHash)(
+    (0, import_lucid34.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid34.validatorToScriptHash)(
         mkStabilityPoolValidatorFromSP(params.stabilityPoolParams)
       ),
       type: "Script"
@@ -4206,7 +4260,7 @@ async function createSpAccount(asset, amount, params, lucid) {
     },
     {
       lovelace: minLovelaces,
-      [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: amount
+      [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: amount
     }
   ).addSignerKey(pkh.hash);
 }
@@ -4232,10 +4286,10 @@ async function adjustSpAccount(asset, amount, accountUtxo, params, lucid) {
     lovelace: BigInt(
       params.stabilityPoolParams.requestCollateralLovelaces + params.stabilityPoolParams.accountAdjustmentFeeLovelaces
     ),
-    [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
+    [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
   };
   if (amount > 0n) {
-    value[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)] = amount;
+    value[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)] = amount;
   }
   return lucid.newTx().readFrom([stabilityPoolScriptRef]).collectFrom(
     [accountUtxo],
@@ -4248,8 +4302,8 @@ async function adjustSpAccount(asset, amount, accountUtxo, params, lucid) {
       }
     })
   ).pay.ToContract(
-    (0, import_lucid33.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid33.validatorToScriptHash)(
+    (0, import_lucid34.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid34.validatorToScriptHash)(
         mkStabilityPoolValidatorFromSP(params.stabilityPoolParams)
       ),
       type: "Script"
@@ -4261,7 +4315,7 @@ async function adjustSpAccount(asset, amount, accountUtxo, params, lucid) {
       })
     },
     value
-  ).addSignerKey((0, import_lucid33.toHex)(oldAccountDatum.owner));
+  ).addSignerKey((0, import_lucid34.toHex)(oldAccountDatum.owner));
 }
 async function closeSpAccount(accountUtxo, params, lucid) {
   const myAddress = await lucid.wallet().address();
@@ -4285,8 +4339,8 @@ async function closeSpAccount(accountUtxo, params, lucid) {
     [accountUtxo],
     serialiseStabilityPoolRedeemer({ RequestAction: request })
   ).pay.ToContract(
-    (0, import_lucid33.credentialToAddress)(lucid.config().network, {
-      hash: (0, import_lucid33.validatorToScriptHash)(
+    (0, import_lucid34.credentialToAddress)(lucid.config().network, {
+      hash: (0, import_lucid34.validatorToScriptHash)(
         mkStabilityPoolValidatorFromSP(params.stabilityPoolParams)
       ),
       type: "Script"
@@ -4299,14 +4353,14 @@ async function closeSpAccount(accountUtxo, params, lucid) {
       lovelace: BigInt(
         params.stabilityPoolParams.requestCollateralLovelaces + params.stabilityPoolParams.accountAdjustmentFeeLovelaces
       ),
-      [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
+      [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
     }
-  ).addSignerKey((0, import_lucid33.toHex)(oldAccountDatum.owner));
+  ).addSignerKey((0, import_lucid34.toHex)(oldAccountDatum.owner));
 }
 async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo, iAssetUtxo, newSnapshotUtxo, params, lucid, collectorOref) {
   const redeemer = {
     ProcessRequest: {
-      txHash: { hash: (0, import_lucid33.fromHex)(accountUtxo.txHash) },
+      txHash: { hash: (0, import_lucid34.fromHex)(accountUtxo.txHash) },
       outputIndex: BigInt(accountUtxo.outputIndex)
     }
   };
@@ -4326,7 +4380,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       lucid
     );
     tx.readFrom([accountTokenScriptRef]);
-    const iassetUnit = params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset);
+    const iassetUnit = params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset);
     const reqAmount = accountUtxo.assets[iassetUnit] ?? 0n;
     const newAccountSnapshot = {
       ...stabilityPoolDatum.poolSnapshot,
@@ -4367,14 +4421,14 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
     const stabilityPoolAssetToken = stabilityPoolUtxo.assets[iassetUnit] ?? 0n;
     const poolOutputValue = {
       lovelace: stabilityPoolUtxo.assets.lovelace + BigInt(params.stabilityPoolParams.accountCreateFeeLovelaces),
-      [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
-      [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: stabilityPoolAssetToken + reqAmount
+      [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
+      [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: stabilityPoolAssetToken + reqAmount
     };
     tx.mintAssets(
       {
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
+        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
       },
-      import_lucid33.Data.to(new import_lucid33.Constr(0, []))
+      import_lucid34.Data.to(new import_lucid34.Constr(0, []))
     );
     tx.pay.ToContract(
       stabilityPoolUtxo.address,
@@ -4404,7 +4458,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       },
       {
         lovelace: accountUtxo.assets.lovelace - BigInt(params.stabilityPoolParams.accountCreateFeeLovelaces),
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
+        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
       }
     );
   } else if ("Adjust" in accountDatum.request) {
@@ -4485,12 +4539,14 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       stabilityPoolDatum.poolSnapshot.scale,
       newPoolSum
     );
-    console.log("balanceChange", balanceChange);
-    console.log("withdrawalFee", withdrawalFee);
-    console.log("rewardLovelacesFee", rewardLovelacesFee);
-    console.log("reward", reward);
     if (rewardLovelacesFee > 0n) {
-      await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collectorOref);
+      await collectorFeeTx(
+        rewardLovelacesFee,
+        lucid,
+        params,
+        tx,
+        collectorOref
+      );
     }
     tx.readFrom([govUtxo, iAssetUtxo, ...refInputs]);
     tx.pay.ToContract(
@@ -4507,8 +4563,8 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       },
       {
         lovelace: stabilityPoolUtxo.assets.lovelace + BigInt(params.stabilityPoolParams.accountAdjustmentFeeLovelaces) - reward,
-        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
-        [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: stabilityPoolUtxo.assets[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)] + balanceChange + withdrawalFee
+        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
+        [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: stabilityPoolUtxo.assets[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)] + balanceChange + withdrawalFee
       }
     );
     tx.pay.ToContract(
@@ -4525,7 +4581,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       },
       {
         lovelace: accountUtxo.assets.lovelace - BigInt(params.stabilityPoolParams.accountAdjustmentFeeLovelaces) - 2000000n,
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
+        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
       }
     );
     if (myAddress !== outputAddress) {
@@ -4533,7 +4589,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         outputAddress,
         {
           kind: "inline",
-          value: import_lucid33.Data.to(
+          value: import_lucid34.Data.to(
             {
               IndigoStabilityPoolAccountAdjustment: {
                 spent_account: {
@@ -4548,7 +4604,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         {
           lovelace: reward - rewardLovelacesFee + 2000000n,
           ...!isDepositOrRewardWithdrawal ? {
-            [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: -balanceChange - withdrawalFee
+            [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: -balanceChange - withdrawalFee
           } : {}
         }
       );
@@ -4605,11 +4661,11 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
     tx.readFrom([govUtxo, iAssetUtxo, accountTokenRef, ...refInputs]);
     tx.mintAssets(
       {
-        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: -1n
+        [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.accountToken[1].unTokenName)]: -1n
       },
-      import_lucid33.Data.to(new import_lucid33.Constr(0, []))
+      import_lucid34.Data.to(new import_lucid34.Constr(0, []))
     );
-    const assetOutputAmountForSP = stabilityPoolUtxo.assets[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)] - fromSPInteger(withdrawnAmt) - withdrawalFeeAmount;
+    const assetOutputAmountForSP = stabilityPoolUtxo.assets[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)] - fromSPInteger(withdrawnAmt) - withdrawalFeeAmount;
     tx.pay.ToContract(
       stabilityPoolUtxo.address,
       {
@@ -4623,9 +4679,9 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       },
       {
         lovelace: stabilityPoolUtxo.assets.lovelace - reward,
-        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid33.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
+        [params.stabilityPoolParams.stabilityPoolToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stabilityPoolParams.stabilityPoolToken[1].unTokenName)]: 1n,
         ...assetOutputAmountForSP > 0n ? {
-          [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: assetOutputAmountForSP
+          [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: assetOutputAmountForSP
         } : {}
       }
     );
@@ -4634,7 +4690,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         outputAddress,
         {
           kind: "inline",
-          value: import_lucid33.Data.to(
+          value: import_lucid34.Data.to(
             {
               IndigoStabilityPoolAccountClosure: {
                 closed_account: {
@@ -4648,7 +4704,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         },
         {
           lovelace: accountUtxo.assets.lovelace + reward - rewardLovelacesFee,
-          [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid33.fromText)(asset)]: fromSPInteger(withdrawnAmt) - withdrawalFeeAmount
+          [params.stabilityPoolParams.assetSymbol.unCurrencySymbol + (0, import_lucid34.fromText)(asset)]: fromSPInteger(withdrawnAmt) - withdrawalFeeAmount
         }
       );
     }
@@ -4657,7 +4713,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
 }
 
 // src/contracts/staking/transactions.ts
-var import_lucid34 = require("@lucid-evolution/lucid");
+var import_lucid35 = require("@lucid-evolution/lucid");
 async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
   const [pkh, _] = await addrDetails(lucid);
   const stakingManagerOut = stakingManagerRef ? await findStakingManagerByOutRef(stakingManagerRef, lucid) : await findStakingManager(params, lucid);
@@ -4682,15 +4738,15 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     }
   };
   const stakingPositionDatum = {
-    owner: (0, import_lucid34.fromHex)(pkh.hash),
+    owner: (0, import_lucid35.fromHex)(pkh.hash),
     lockedAmount: /* @__PURE__ */ new Map([]),
     positionSnapshot: {
       snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda
     }
   };
-  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.stakingToken[1].unTokenName);
-  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.indyToken[1].unTokenName);
-  return lucid.newTx().collectFrom([stakingManagerOut.utxo], import_lucid34.Data.to(new import_lucid34.Constr(0, [pkh.hash]))).readFrom([stakingRefScriptUtxo]).pay.ToContract(
+  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingToken[1].unTokenName);
+  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
+  return lucid.newTx().collectFrom([stakingManagerOut.utxo], import_lucid35.Data.to(new import_lucid35.Constr(0, [pkh.hash]))).readFrom([stakingRefScriptUtxo]).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
       kind: "inline",
@@ -4701,7 +4757,7 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     {
       [stakingToken]: 1n
     },
-    import_lucid34.Data.void()
+    import_lucid35.Data.void()
   ).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
@@ -4727,18 +4783,26 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
     ]),
     (_) => new Error("Expected a single staking Ref Script UTXO")
   );
-  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.stakingToken[1].unTokenName);
-  const stakingManagerToken = params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName);
-  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.indyToken[1].unTokenName);
+  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingToken[1].unTokenName);
+  const stakingManagerToken = params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName);
+  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
   const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
   const currentSnapshotAda = stakingManagerOut.datum.managerSnapshot.snapshotAda;
   const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
-  const adaReward = (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / (1000000n * 1000000n);
+  const adaReward = (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / rewardSnapshotPrecision;
   const newLockedAmount = updateStakingLockedAmount(
     stakingPositionOut.datum.lockedAmount,
     BigInt(now)
   );
-  return lucid.newTx().validFrom(Date.now()).readFrom([stakingRefScriptUtxo]).collectFrom([stakingPositionOut.utxo], import_lucid34.Data.to(new import_lucid34.Constr(3, [amount]))).collectFrom([stakingManagerOut.utxo], import_lucid34.Data.to(new import_lucid34.Constr(1, []))).pay.ToContract(
+  return lucid.newTx().validFrom(Date.now()).readFrom([stakingRefScriptUtxo]).collectFrom(
+    [stakingPositionOut.utxo],
+    serialiseStakingRedeemer({
+      AdjustStakedAmount: { adjustAmount: amount }
+    })
+  ).collectFrom(
+    [stakingManagerOut.utxo],
+    serialiseStakingRedeemer("UpdateTotalStake")
+  ).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
       kind: "inline",
@@ -4764,7 +4828,7 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
       [stakingToken]: 1n,
       [indyToken]: stakingPositionOut.utxo.assets[indyToken] + amount
     }
-  ).addSignerKey((0, import_lucid34.toHex)(stakingPositionOut.datum.owner));
+  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionOut.datum.owner));
 }
 async function closeStakingPosition(stakingPositionRef, params, lucid, stakingManagerRef) {
   const stakingPositionOut = await findStakingPositionByOutRef(
@@ -4786,14 +4850,14 @@ async function closeStakingPosition(stakingPositionRef, params, lucid, stakingMa
     ]),
     (_) => new Error("Expected a single staking token policy Ref Script UTXO")
   );
-  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.stakingToken[1].unTokenName);
-  const stakingManagerToken = params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName);
-  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid34.fromText)(params.stakingParams.indyToken[1].unTokenName);
+  const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingToken[1].unTokenName);
+  const stakingManagerToken = params.stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingManagerNFT[1].unTokenName);
+  const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
   const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
   const currentSnapshotAda = stakingManagerOut.datum.managerSnapshot.snapshotAda;
   const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
   const adaReward = (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / (1000000n * 1000000n);
-  return lucid.newTx().validFrom(Date.now()).readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo]).collectFrom([stakingPositionOut.utxo], import_lucid34.Data.to(new import_lucid34.Constr(4, []))).collectFrom([stakingManagerOut.utxo], import_lucid34.Data.to(new import_lucid34.Constr(1, []))).pay.ToContract(
+  return lucid.newTx().validFrom(Date.now()).readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo]).collectFrom([stakingPositionOut.utxo], import_lucid35.Data.to(new import_lucid35.Constr(4, []))).collectFrom([stakingManagerOut.utxo], import_lucid35.Data.to(new import_lucid35.Constr(1, []))).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
       kind: "inline",
@@ -4810,37 +4874,91 @@ async function closeStakingPosition(stakingPositionRef, params, lucid, stakingMa
     {
       [stakingToken]: -1n
     },
-    import_lucid34.Data.void()
-  ).addSignerKey((0, import_lucid34.toHex)(stakingPositionOut.datum.owner));
+    import_lucid35.Data.void()
+  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionOut.datum.owner));
+}
+var MIN_UTXO_AMOUNT = 2000000n;
+async function distributeAda(stakingManagerRef, collectorRefs, params, lucid) {
+  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo)
+  );
+  const collectorUtxos = (await lucid.utxosByOutRef(collectorRefs)).filter((utxo) => utxo.datum && utxo.datum === import_lucid35.Data.void()).filter((utxo) => utxo.assets.lovelace > MIN_UTXO_AMOUNT);
+  if (collectorUtxos.length === 0) {
+    throw new Error("No available collectors found");
+  }
+  const adaRewardCollected = collectorUtxos.reduce(
+    (acc, utxo) => acc + utxo.assets.lovelace - MIN_UTXO_AMOUNT,
+    0n
+  );
+  const newSnapshot = distributeReward(
+    stakingManagerDatum.managerSnapshot.snapshotAda,
+    adaRewardCollected,
+    stakingManagerDatum.totalStake
+  );
+  const stakingRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef)
+    ]),
+    (_) => new Error("Expected a single staking Ref Script UTXO")
+  );
+  const collectorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(params.scriptReferences.collectorValidatorRef)
+    ]),
+    (_) => new Error("Expected a single staking Ref Script UTXO")
+  );
+  const tx = lucid.newTx().readFrom([stakingRefScriptUtxo, collectorRefScriptUtxo]).collectFrom([stakingManagerUtxo], serialiseStakingRedeemer("Distribute")).collectFrom(
+    collectorUtxos,
+    serialiseCollectorRedeemer("DistributeToStakers")
+  ).pay.ToContract(
+    stakingManagerUtxo.address,
+    {
+      kind: "inline",
+      value: serialiseStakingDatum({
+        ...stakingManagerDatum,
+        managerSnapshot: { snapshotAda: newSnapshot }
+      })
+    },
+    (0, import_lucid35.addAssets)(stakingManagerUtxo.assets, mkLovelacesOf(adaRewardCollected))
+  );
+  for (const collectorUtxo of collectorUtxos) {
+    tx.pay.ToContract(
+      collectorUtxo.address,
+      { kind: "inline", value: import_lucid35.Data.void() },
+      mkLovelacesOf(MIN_UTXO_AMOUNT)
+    );
+  }
+  return tx;
 }
 
 // src/contracts/interest-oracle/transactions.ts
-var import_lucid39 = require("@lucid-evolution/lucid");
+var import_lucid40 = require("@lucid-evolution/lucid");
 
 // src/contracts/one-shot/transactions.ts
-var import_lucid37 = require("@lucid-evolution/lucid");
+var import_lucid38 = require("@lucid-evolution/lucid");
 
 // src/contracts/one-shot/scripts.ts
-var import_lucid36 = require("@lucid-evolution/lucid");
+var import_lucid37 = require("@lucid-evolution/lucid");
 
 // src/contracts/one-shot/types.ts
-var import_lucid35 = require("@lucid-evolution/lucid");
-var OneShotParamsSchema = import_lucid35.Data.Object({
-  referenceOutRef: import_lucid35.Data.Object({
-    txHash: import_lucid35.Data.Bytes(),
-    outputIdx: import_lucid35.Data.Integer()
+var import_lucid36 = require("@lucid-evolution/lucid");
+var OneShotParamsSchema = import_lucid36.Data.Object({
+  referenceOutRef: import_lucid36.Data.Object({
+    txHash: import_lucid36.Data.Bytes(),
+    outputIdx: import_lucid36.Data.Integer()
   }),
-  mintAmounts: import_lucid35.Data.Array(
-    import_lucid35.Data.Object({
+  mintAmounts: import_lucid36.Data.Array(
+    import_lucid36.Data.Object({
       /// Use hex encoded string
-      tokenName: import_lucid35.Data.Bytes(),
-      amount: import_lucid35.Data.Integer()
+      tokenName: import_lucid36.Data.Bytes(),
+      amount: import_lucid36.Data.Integer()
     })
   )
 });
 var OneShotParams = OneShotParamsSchema;
 function castOneShotParams(params) {
-  return import_lucid35.Data.castTo(params, OneShotParams);
+  return import_lucid36.Data.castTo(params, OneShotParams);
 }
 
 // src/contracts/one-shot/scripts.ts
@@ -4851,7 +4969,7 @@ var oneShotPolicyData = {
 function mkOneShotPolicy(params) {
   return {
     type: oneShotPolicyData.type,
-    script: (0, import_lucid36.applyParamsToScript)(oneShotPolicyData.cborHex, [
+    script: (0, import_lucid37.applyParamsToScript)(oneShotPolicyData.cborHex, [
       castOneShotParams(params)
     ])
   };
@@ -4861,7 +4979,7 @@ function mkOneShotPolicy(params) {
 var import_Array = require("fp-ts/lib/Array");
 async function oneShotMintTx(lucid, params) {
   const oneShotPolicy = mkOneShotPolicy(params);
-  const policyId = (0, import_lucid37.mintingPolicyToId)(oneShotPolicy);
+  const policyId = (0, import_lucid38.mintingPolicyToId)(oneShotPolicy);
   const refUtxo = matchSingle(
     await lucid.utxosByOutRef([
       {
@@ -4877,11 +4995,11 @@ async function oneShotMintTx(lucid, params) {
     lucid.newTx().collectFrom([refUtxo]).mintAssets(
       (0, import_Array.reduce)(
         {},
-        (acc, entry) => (0, import_lucid37.addAssets)(acc, {
-          [(0, import_lucid37.toUnit)(policyId, entry.tokenName)]: entry.amount
+        (acc, entry) => (0, import_lucid38.addAssets)(acc, {
+          [(0, import_lucid38.toUnit)(policyId, entry.tokenName)]: entry.amount
         })
       )(params.mintAmounts),
-      import_lucid37.Data.to(new import_lucid37.Constr(0, []))
+      import_lucid38.Data.to(new import_lucid38.Constr(0, []))
     ).attach.MintingPolicy(oneShotPolicy),
     policyId
   ];
@@ -4894,7 +5012,7 @@ async function runOneShotMintTx(lucid, params) {
 }
 
 // src/contracts/interest-oracle/scripts.ts
-var import_lucid38 = require("@lucid-evolution/lucid");
+var import_lucid39 = require("@lucid-evolution/lucid");
 
 // src/validators/interest-oracle-validator.ts
 var _interestOracleValidator = {
@@ -4907,7 +5025,7 @@ var _interestOracleValidator = {
 function mkInterestOracleValidator(params) {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid38.applyParamsToScript)(_interestOracleValidator.cborHex, [
+    script: (0, import_lucid39.applyParamsToScript)(_interestOracleValidator.cborHex, [
       castInterestOracleParams(params)
     ])
   };
@@ -4932,14 +5050,14 @@ async function startInterestOracle(initialUnitaryInterest, initialInterestRate,
     },
     mintAmounts: [
       {
-        tokenName: (0, import_lucid39.fromText)(tokenName),
+        tokenName: (0, import_lucid40.fromText)(tokenName),
         amount: 1n
       }
     ]
   });
   const validator = mkInterestOracleValidator(oracleParams);
   tx.pay.ToContract(
-    (0, import_lucid39.validatorToAddress)(network, validator),
+    (0, import_lucid40.validatorToAddress)(network, validator),
     {
       kind: "inline",
       value: serialiseInterestOracleDatum({
@@ -4952,12 +5070,12 @@ async function startInterestOracle(initialUnitaryInterest, initialInterestRate,
     },
     {
       lovelace: 2500000n,
-      [(0, import_lucid39.toUnit)(policyId, (0, import_lucid39.fromText)(tokenName))]: 1n
+      [(0, import_lucid40.toUnit)(policyId, (0, import_lucid40.fromText)(tokenName))]: 1n
     }
   );
   if (withScriptRef) {
     tx.pay.ToAddressWithData(
-      (0, import_lucid39.validatorToAddress)(network, validator),
+      (0, import_lucid40.validatorToAddress)(network, validator),
       void 0,
       void 0,
       validator
@@ -4967,7 +5085,7 @@ async function startInterestOracle(initialUnitaryInterest, initialInterestRate,
     tx,
     {
       currencySymbol: policyId,
-      tokenName: (0, import_lucid39.fromText)(tokenName)
+      tokenName: (0, import_lucid40.fromText)(tokenName)
     }
   ];
 }
@@ -5015,17 +5133,17 @@ async function feedInterestOracle(params, newInterestRate, lucid, assetClass, ut
 }
 
 // src/contracts/version-registry/types.ts
-var import_lucid40 = require("@lucid-evolution/lucid");
-var VersionRecordTokenParamsSchema = import_lucid40.Data.Object({
+var import_lucid41 = require("@lucid-evolution/lucid");
+var VersionRecordTokenParamsSchema = import_lucid41.Data.Object({
   upgradeToken: AssetClassSchema
 });
 var VersionRecordTokenParams = VersionRecordTokenParamsSchema;
 function castVersionRecordTokenParams(params) {
-  return import_lucid40.Data.castTo(params, VersionRecordTokenParams);
+  return import_lucid41.Data.castTo(params, VersionRecordTokenParams);
 }
 
 // src/contracts/version-registry/scripts.ts
-var import_lucid41 = require("@lucid-evolution/lucid");
+var import_lucid42 = require("@lucid-evolution/lucid");
 
 // src/validators/version-record-policy.ts
 var _versionRecordTokenPolicy = {
@@ -5045,7 +5163,7 @@ var _versionRegistryValidator = {
 function mkVersionRecordTokenPolicy(params) {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid41.applyParamsToScript)(_versionRecordTokenPolicy.cborHex, [
+    script: (0, import_lucid42.applyParamsToScript)(_versionRecordTokenPolicy.cborHex, [
       castVersionRecordTokenParams(params)
     ])
   };
@@ -5058,7 +5176,7 @@ var mkVersionRegistryValidator = () => {
 };
 
 // src/contracts/collector/scripts.ts
-var import_lucid42 = require("@lucid-evolution/lucid");
+var import_lucid43 = require("@lucid-evolution/lucid");
 
 // src/validators/collector-validator.ts
 var _collectorValidator = {
@@ -5071,19 +5189,19 @@ var _collectorValidator = {
 var mkCollectorValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid42.applyParamsToScript)(_collectorValidator.cborHex, [
-      new import_lucid42.Constr(0, [
-        new import_lucid42.Constr(0, [
+    script: (0, import_lucid43.applyParamsToScript)(_collectorValidator.cborHex, [
+      new import_lucid43.Constr(0, [
+        new import_lucid43.Constr(0, [
           params.stakingManagerNFT[0].unCurrencySymbol,
-          (0, import_lucid42.fromText)(params.stakingManagerNFT[1].unTokenName)
+          (0, import_lucid43.fromText)(params.stakingManagerNFT[1].unTokenName)
         ]),
-        new import_lucid42.Constr(0, [
+        new import_lucid43.Constr(0, [
           params.stakingToken[0].unCurrencySymbol,
-          (0, import_lucid42.fromText)(params.stakingToken[1].unTokenName)
+          (0, import_lucid43.fromText)(params.stakingToken[1].unTokenName)
         ]),
-        new import_lucid42.Constr(0, [
+        new import_lucid43.Constr(0, [
           params.versionRecordToken[0].unCurrencySymbol,
-          (0, import_lucid42.fromText)(params.versionRecordToken[1].unTokenName)
+          (0, import_lucid43.fromText)(params.versionRecordToken[1].unTokenName)
         ])
       ])
     ])
@@ -5091,7 +5209,7 @@ var mkCollectorValidatorFromSP = (params) => {
 };
 
 // src/contracts/treasury/scripts.ts
-var import_lucid43 = require("@lucid-evolution/lucid");
+var import_lucid44 = require("@lucid-evolution/lucid");
 
 // src/validators/treasury-validator.ts
 var _treasuryValidator = {
@@ -5104,30 +5222,30 @@ var _treasuryValidator = {
 var mkTreasuryValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid43.applyParamsToScript)(_treasuryValidator.cborHex, [
-      new import_lucid43.Constr(0, [
-        new import_lucid43.Constr(0, [
+    script: (0, import_lucid44.applyParamsToScript)(_treasuryValidator.cborHex, [
+      new import_lucid44.Constr(0, [
+        new import_lucid44.Constr(0, [
           params.upgradeToken[0].unCurrencySymbol,
-          (0, import_lucid43.fromText)(params.upgradeToken[1].unTokenName)
+          (0, import_lucid44.fromText)(params.upgradeToken[1].unTokenName)
         ]),
-        new import_lucid43.Constr(0, [
+        new import_lucid44.Constr(0, [
           params.versionRecordToken[0].unCurrencySymbol,
-          (0, import_lucid43.fromText)(params.versionRecordToken[1].unTokenName)
+          (0, import_lucid44.fromText)(params.versionRecordToken[1].unTokenName)
         ]),
-        params.treasuryUtxosStakeCredential ? new import_lucid43.Constr(0, [
-          new import_lucid43.Constr(0, [
-            new import_lucid43.Constr(1, [
+        params.treasuryUtxosStakeCredential ? new import_lucid44.Constr(0, [
+          new import_lucid44.Constr(0, [
+            new import_lucid44.Constr(1, [
               params.treasuryUtxosStakeCredential.contents.contents
             ])
           ])
-        ]) : new import_lucid43.Constr(1, [])
+        ]) : new import_lucid44.Constr(1, [])
       ])
     ])
   };
 };
 
 // src/contracts/execute/scripts.ts
-var import_lucid44 = require("@lucid-evolution/lucid");
+var import_lucid45 = require("@lucid-evolution/lucid");
 
 // src/validators/execute-validator.ts
 var _executeValidator = {
@@ -5140,8 +5258,8 @@ var _executeValidator = {
 var mkExecuteValidator = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid44.applySingleCborEncoding)(
-      (0, import_lucid44.applyParamsToScript)(_executeValidator.cborHex, [
+    script: (0, import_lucid45.applySingleCborEncoding)(
+      (0, import_lucid45.applyParamsToScript)(_executeValidator.cborHex, [
         castExecuteParams(params)
       ])
     )
@@ -5150,8 +5268,8 @@ var mkExecuteValidator = (params) => {
 var mkExecuteValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid44.applySingleCborEncoding)(
-      (0, import_lucid44.applyParamsToScript)(_executeValidator.cborHex, [
+    script: (0, import_lucid45.applySingleCborEncoding)(
+      (0, import_lucid45.applyParamsToScript)(_executeValidator.cborHex, [
         castExecuteParams({
           govNFT: fromSystemParamsAsset(params.govNFT),
           upgradeToken: fromSystemParamsAsset(params.upgradeToken),
@@ -5169,62 +5287,276 @@ var mkExecuteValidatorFromSP = (params) => {
   };
 };
 
+// src/contracts/lrp/helpers.ts
+var import_lucid47 = require("@lucid-evolution/lucid");
+
 // src/contracts/lrp/types.ts
-var import_lucid45 = require("@lucid-evolution/lucid");
-var LRPParamsSchema = import_lucid45.Data.Object({
+var import_lucid46 = require("@lucid-evolution/lucid");
+var import_fp_ts11 = require("fp-ts");
+var LRPParamsSchema = import_lucid46.Data.Object({
   versionRecordToken: AssetClassSchema,
   iassetNft: AssetClassSchema,
-  iassetPolicyId: import_lucid45.Data.Bytes(),
-  minRedemptionLovelacesAmt: import_lucid45.Data.Integer()
+  iassetPolicyId: import_lucid46.Data.Bytes(),
+  minRedemptionLovelacesAmt: import_lucid46.Data.Integer()
 });
 var LRPParams = LRPParamsSchema;
-var LRPDatumSchema = import_lucid45.Data.Object({
-  owner: import_lucid45.Data.Bytes(),
-  iasset: import_lucid45.Data.Bytes(),
+var LRPDatumSchema = import_lucid46.Data.Object({
+  owner: import_lucid46.Data.Bytes(),
+  iasset: import_lucid46.Data.Bytes(),
   maxPrice: OnChainDecimalSchema,
   /**
    * The amount of lovelaces that is available to be spent.
    * This doesn't correspond to the lovelaces in UTXO's value,
    * since that can contain fees, too.
    */
-  lovelacesToSpend: import_lucid45.Data.Integer()
+  lovelacesToSpend: import_lucid46.Data.Integer()
 });
 var LRPDatum = LRPDatumSchema;
-var LRPRedeemerSchema = import_lucid45.Data.Enum([
-  import_lucid45.Data.Object({ Redeem: import_lucid45.Data.Object({ continuingOutputIdx: import_lucid45.Data.Integer() }) }),
-  import_lucid45.Data.Object({
-    RedeemAuxiliary: import_lucid45.Data.Object({
-      continuingOutputIdx: import_lucid45.Data.Integer(),
+var LRPRedeemerSchema = import_lucid46.Data.Enum([
+  import_lucid46.Data.Object({ Redeem: import_lucid46.Data.Object({ continuingOutputIdx: import_lucid46.Data.Integer() }) }),
+  import_lucid46.Data.Object({
+    RedeemAuxiliary: import_lucid46.Data.Object({
+      continuingOutputIdx: import_lucid46.Data.Integer(),
       mainRedeemOutRef: OutputReferenceSchema,
-      asset: import_lucid45.Data.Bytes(),
+      asset: import_lucid46.Data.Bytes(),
       assetPrice: OnChainDecimalSchema,
       redemptionReimbursementPercentage: OnChainDecimalSchema
     })
   }),
-  import_lucid45.Data.Literal("Cancel"),
-  import_lucid45.Data.Literal("UpgradeVersion")
+  import_lucid46.Data.Literal("Cancel"),
+  import_lucid46.Data.Literal("UpgradeVersion")
 ]);
 var LRPRedeemer = LRPRedeemerSchema;
 function parseLrpDatum(datum) {
-  return import_lucid45.Data.from(datum, LRPDatum);
+  try {
+    return import_fp_ts11.option.some(import_lucid46.Data.from(datum, LRPDatum));
+  } catch (_) {
+    return import_fp_ts11.option.none;
+  }
+}
+function parseLrpDatumOrThrow(datum) {
+  return import_fp_ts11.function.pipe(
+    parseLrpDatum(datum),
+    import_fp_ts11.option.match(() => {
+      throw new Error("Expected an LRP datum.");
+    }, import_fp_ts11.function.identity)
+  );
 }
 function serialiseLrpDatum(datum) {
-  return import_lucid45.Data.to(datum, LRPDatum);
+  return import_lucid46.Data.to(datum, LRPDatum);
 }
 function serialiseLrpRedeemer(redeemer) {
-  return import_lucid45.Data.to(redeemer, LRPRedeemer);
+  return import_lucid46.Data.to(redeemer, LRPRedeemer);
 }
 function castLrpParams(params) {
-  return import_lucid45.Data.castTo(params, LRPParams);
+  return import_lucid46.Data.castTo(params, LRPParams);
 }
 
-// src/contracts/lrp/transactions.ts
-var import_lucid46 = require("@lucid-evolution/lucid");
+// src/contracts/lrp/helpers.ts
+var import_fp_ts13 = require("fp-ts");
+
+// src/utils/array-utils.ts
+var import_fp_ts12 = require("fp-ts");
+function shuffle(arr) {
+  const source = [...arr];
+  for (let i = source.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [source[i], source[j]] = [source[j], source[i]];
+  }
+  return source;
+}
+function insertSorted(arr, item, ord) {
+  if (arr.length === 0) {
+    return [item];
+  }
+  const arrOrd = ord.compare(arr[0], arr[arr.length - 1]);
+  if (arrOrd === 0) {
+    if (ord.compare(arr[0], item) === -1) {
+      return [...arr, item];
+    } else {
+      return [item, ...arr];
+    }
+  }
+  for (let i = 0; i < arr.length; i++) {
+    if (ord.compare(arr[i], item) !== arrOrd) {
+      return [...import_fp_ts12.array.takeLeft(i)(arr), item, ...import_fp_ts12.array.takeRight(arr.length - i)(arr)];
+    }
+  }
+  return [...arr, item];
+}
+
+// src/contracts/lrp/helpers.ts
 var import_ts_pattern12 = require("ts-pattern");
+var MIN_LRP_COLLATERAL_AMT = 2000000n;
+function lrpRedeemableLovelacesInclReimb(lrp, lrpParams) {
+  const datum = lrp[1];
+  const utxo = lrp[0];
+  let res = 0n;
+  if (datum.lovelacesToSpend > lovelacesAmt(utxo.assets)) {
+    res = bigintMax(lovelacesAmt(utxo.assets) - MIN_LRP_COLLATERAL_AMT, 0n);
+  } else {
+    res = datum.lovelacesToSpend;
+  }
+  if (res < lrpParams.minRedemptionLovelacesAmt) {
+    return 0n;
+  }
+  return res;
+}
+function buildRedemptionsTx(redemptions, price, redemptionReimbursementPercentage, sysParams, tx, txOutputsBeforeCount) {
+  const [[mainLrpUtxo, _], __] = (0, import_ts_pattern12.match)(redemptions).with(
+    [import_ts_pattern12.P._, ...import_ts_pattern12.P.array()],
+    ([[firstLrp, _2], ...rest]) => [
+      [firstLrp, _2],
+      rest
+    ]
+  ).otherwise(() => {
+    throw new Error("Expects at least 1 UTXO to redeem.");
+  });
+  const mainLrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(mainLrpUtxo));
+  return import_fp_ts13.function.pipe(
+    redemptions,
+    import_fp_ts13.array.reduceWithIndex(
+      tx,
+      (idx, acc, [lrpUtxo, redeemIAssetAmt]) => {
+        const lovelacesForRedemption = ocdMul(
+          {
+            getOnChainInt: redeemIAssetAmt
+          },
+          price
+        ).getOnChainInt;
+        const reimburstmentLovelaces = calculateFeeFromPercentage(
+          redemptionReimbursementPercentage,
+          lovelacesForRedemption
+        );
+        const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
+        const resultVal = (0, import_lucid47.addAssets)(
+          lrpUtxo.assets,
+          mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
+          mkAssetsOf(
+            {
+              currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
+              tokenName: mainLrpDatum.iasset
+            },
+            redeemIAssetAmt
+          )
+        );
+        if (lovelacesAmt(resultVal) < MIN_LRP_COLLATERAL_AMT) {
+          throw new Error("LRP was incorrectly initialised.");
+        }
+        return acc.collectFrom(
+          [lrpUtxo],
+          serialiseLrpRedeemer(
+            idx === 0 ? { Redeem: { continuingOutputIdx: txOutputsBeforeCount + 0n } } : {
+              RedeemAuxiliary: {
+                continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
+                mainRedeemOutRef: {
+                  txHash: { hash: mainLrpUtxo.txHash },
+                  outputIndex: BigInt(mainLrpUtxo.outputIndex)
+                },
+                asset: mainLrpDatum.iasset,
+                assetPrice: price,
+                redemptionReimbursementPercentage
+              }
+            }
+          )
+        ).pay.ToContract(
+          lrpUtxo.address,
+          {
+            kind: "inline",
+            value: serialiseLrpDatum({
+              ...lrpDatum,
+              lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
+            })
+          },
+          resultVal
+        );
+      }
+    )
+  );
+}
+function calculateTotalAdaForRedemption(iasset, iassetPrice, lrpParams, allLrps, maxLrpsInTx) {
+  return import_fp_ts13.function.pipe(
+    allLrps,
+    import_fp_ts13.array.filterMap(([utxo, datum]) => {
+      if (datum.iasset !== iasset || datum.maxPrice.getOnChainInt < iassetPrice.getOnChainInt) {
+        return import_fp_ts13.option.none;
+      }
+      const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
+        [utxo, datum],
+        lrpParams
+      );
+      if (lovelacesToSpend === 0n) {
+        return import_fp_ts13.option.none;
+      }
+      return import_fp_ts13.option.some(lovelacesToSpend);
+    }),
+    // From largest to smallest
+    import_fp_ts13.array.sort(import_fp_ts13.ord.reverse(BigIntOrd)),
+    // We can fit only this number of redemptions with CDP open into a single Tx.
+    import_fp_ts13.array.takeLeft(maxLrpsInTx),
+    sum
+  );
+}
+function randomLrpsSubsetSatisfyingTargetLovelaces(iasset, targetLovelacesToSpend, iassetPrice, allLrps, lrpParams, maxLrpsInTx, randomiseFn = shuffle) {
+  if (targetLovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
+    throw new Error("Can't redeem less than the minimum.");
+  }
+  const shuffled = randomiseFn(
+    import_fp_ts13.function.pipe(
+      allLrps,
+      import_fp_ts13.array.filter(
+        ([_, datum]) => datum.iasset === iasset && datum.maxPrice.getOnChainInt >= iassetPrice.getOnChainInt
+      )
+    )
+  );
+  let result = [];
+  let runningSum = 0n;
+  for (let i = 0; i < shuffled.length; i++) {
+    const element = shuffled[i];
+    const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
+      element,
+      lrpParams
+    );
+    if (lovelacesToSpend < lrpParams.minRedemptionLovelacesAmt) {
+      continue;
+    }
+    if (result.length > 0 && targetLovelacesToSpend - runningSum < lrpParams.minRedemptionLovelacesAmt) {
+      const last = result[result.length - 1];
+      if (lrpRedeemableLovelacesInclReimb(last, lrpParams) < lovelacesToSpend) {
+        const popped = result.pop();
+        runningSum -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
+      } else {
+        continue;
+      }
+    }
+    result = insertSorted(
+      result,
+      element,
+      import_fp_ts13.ord.contramap(
+        ([_, dat]) => dat.lovelacesToSpend
+        // From highest to lowest
+      )(import_fp_ts13.ord.reverse(BigIntOrd))
+    );
+    runningSum += lovelacesToSpend;
+    if (result.length > maxLrpsInTx) {
+      const popped = result.pop();
+      runningSum -= lrpRedeemableLovelacesInclReimb(popped, lrpParams);
+    }
+    if (runningSum >= targetLovelacesToSpend) {
+      return result;
+    }
+  }
+  if (targetLovelacesToSpend - runningSum >= lrpParams.minRedemptionLovelacesAmt) {
+    throw new Error("Couldn't achieve target lovelaces");
+  }
+  return result;
+}
+
+// src/contracts/lrp/transactions.ts
+var import_lucid48 = require("@lucid-evolution/lucid");
 var import_Array2 = require("fp-ts/lib/Array");
-var import_Array3 = require("fp-ts/lib/Array");
-var MIN_UTXO_COLLATERAL_AMT = 2000000n;
-async function openLrp(assetTokenName, lovelacesAmt2, maxPrice, lucid, lrpScriptHash, network, lrpStakeCredential) {
+async function openLrp(assetTokenName, lovelacesAmt2, maxPrice, lucid, sysParams, lrpStakeCredential) {
+  const network = lucid.config().network;
   const [ownPkh, _] = await addrDetails(lucid);
   const newDatum = {
     owner: ownPkh.hash,
@@ -5233,38 +5565,47 @@ async function openLrp(assetTokenName, lovelacesAmt2, maxPrice, lucid, lrpScript
     lovelacesToSpend: lovelacesAmt2
   };
   return lucid.newTx().pay.ToContract(
-    createScriptAddress(network, lrpScriptHash, lrpStakeCredential),
+    createScriptAddress(
+      network,
+      sysParams.validatorHashes.lrpHash,
+      lrpStakeCredential
+    ),
     {
       kind: "inline",
       value: serialiseLrpDatum(newDatum)
     },
-    { lovelace: lovelacesAmt2 + MIN_UTXO_COLLATERAL_AMT }
+    { lovelace: lovelacesAmt2 + MIN_LRP_COLLATERAL_AMT }
   );
 }
-async function cancelLrp(lrpOutRef, lrpRefScriptOutRef, lucid) {
+async function cancelLrp(lrpOutRef, sysParams, lucid) {
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef)
+    ]),
     (_) => new Error("Expected a single LRP Ref Script UTXO")
   );
   const lrpUtxo = matchSingle(
     await lucid.utxosByOutRef([lrpOutRef]),
     (_) => new Error("Expected a single LRP UTXO.")
   );
-  const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
   return lucid.newTx().readFrom([lrpScriptRefUtxo]).collectFrom([lrpUtxo], serialiseLrpRedeemer("Cancel")).addSignerKey(lrpDatum.owner);
 }
-async function redeemLrp(redemptionLrpsData, lrpRefScriptOutRef, priceOracleOutRef, iassetOutRef, lucid, lrpParams, network) {
+async function redeemLrp(redemptionLrpsData, priceOracleOutRef, iassetOutRef, lucid, sysParams) {
+  const network = lucid.config().network;
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
-    (_2) => new Error("Expected a single LRP Ref Script UTXO")
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef)
+    ]),
+    (_) => new Error("Expected a single LRP Ref Script UTXO")
   );
   const priceOracleUtxo = matchSingle(
     await lucid.utxosByOutRef([priceOracleOutRef]),
-    (_2) => new Error("Expected a single price oracle UTXO")
+    (_) => new Error("Expected a single price oracle UTXO")
   );
   const iassetUtxo = matchSingle(
     await lucid.utxosByOutRef([iassetOutRef]),
-    (_2) => new Error("Expected a single IAsset UTXO")
+    (_) => new Error("Expected a single IAsset UTXO")
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
@@ -5274,88 +5615,35 @@ async function redeemLrp(redemptionLrpsData, lrpRefScriptOutRef, priceOracleOutR
     getInlineDatumOrThrow(priceOracleUtxo)
   );
   const redemptionLrps = await lucid.utxosByOutRef(lrpsToRedeemOutRefs).then((val) => (0, import_Array2.zip)(val, lrpRedemptionIAssetAmt));
-  const [[mainLrpUtxo, _], __] = (0, import_ts_pattern12.match)(redemptionLrps).with(
-    [import_ts_pattern12.P._, ...import_ts_pattern12.P.array()],
-    ([[firstLrp, _2], ...rest]) => [
-      [firstLrp, _2],
-      rest
-    ]
-  ).otherwise(() => {
-    throw new Error("Expects at least 1 UTXO to redeem.");
-  });
-  const mainLrpDatum = parseLrpDatum(getInlineDatumOrThrow(mainLrpUtxo));
-  const tx = (0, import_Array3.reduceWithIndex)(
+  const tx = buildRedemptionsTx(
+    redemptionLrps,
+    priceOracleDatum.price,
+    iassetDatum.redemptionReimbursementPercentage,
+    sysParams,
     lucid.newTx(),
-    (idx, acc, [lrpUtxo, redeemIAssetAmt]) => {
-      const lovelacesForRedemption = ocdMul(
-        {
-          getOnChainInt: redeemIAssetAmt
-        },
-        priceOracleDatum.price
-      ).getOnChainInt;
-      const reimburstmentLovelaces = calculateFeeFromPercentage(
-        iassetDatum.redemptionReimbursementPercentage,
-        lovelacesForRedemption
-      );
-      const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
-      return acc.collectFrom(
-        [lrpUtxo],
-        serialiseLrpRedeemer(
-          idx === 0 ? { Redeem: { continuingOutputIdx: 0n } } : {
-            RedeemAuxiliary: {
-              continuingOutputIdx: BigInt(idx),
-              mainRedeemOutRef: {
-                txHash: { hash: mainLrpUtxo.txHash },
-                outputIndex: BigInt(mainLrpUtxo.outputIndex)
-              },
-              asset: mainLrpDatum.iasset,
-              assetPrice: priceOracleDatum.price,
-              redemptionReimbursementPercentage: iassetDatum.redemptionReimbursementPercentage
-            }
-          }
-        )
-      ).pay.ToContract(
-        lrpUtxo.address,
-        {
-          kind: "inline",
-          value: serialiseLrpDatum({
-            ...lrpDatum,
-            lovelacesToSpend: lrpDatum.lovelacesToSpend - lovelacesForRedemption
-          })
-        },
-        (0, import_lucid46.addAssets)(
-          lrpUtxo.assets,
-          mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
-          mkAssetsOf(
-            {
-              currencySymbol: lrpParams.iassetPolicyId,
-              tokenName: mainLrpDatum.iasset
-            },
-            redeemIAssetAmt
-          )
-        )
-      );
-    }
-  )(redemptionLrps);
+    0n
+  );
   return lucid.newTx().validTo(
-    (0, import_lucid46.slotToUnixTime)(
+    (0, import_lucid48.slotToUnixTime)(
       network,
-      (0, import_lucid46.unixTimeToSlot)(network, Number(priceOracleDatum.expiration)) - 1
+      (0, import_lucid48.unixTimeToSlot)(network, Number(priceOracleDatum.expiration)) - 1
     )
   ).readFrom([lrpScriptRefUtxo]).readFrom([iassetUtxo, priceOracleUtxo]).compose(tx);
 }
-async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, lrpRefScriptOutRef, lrpParams) {
+async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, sysParams) {
   const lrpScriptRefUtxo = matchSingle(
-    await lucid.utxosByOutRef([lrpRefScriptOutRef]),
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef)
+    ]),
     (_) => new Error("Expected a single LRP Ref Script UTXO")
   );
   const lrpUtxo = matchSingle(
     await lucid.utxosByOutRef([lrpOutRef]),
     (_) => new Error("Expected a single LRP UTXO.")
   );
-  const lrpDatum = parseLrpDatum(getInlineDatumOrThrow(lrpUtxo));
+  const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
   const rewardAssetClass = {
-    currencySymbol: lrpParams.iassetPolicyId,
+    currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
     tokenName: lrpDatum.iasset
   };
   const rewardAssetsAmt = assetClassValueOf(lrpUtxo.assets, rewardAssetClass);
@@ -5378,19 +5666,19 @@ async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, lrpRefScriptOutRe
         lovelacesToSpend: lrpDatum.lovelacesToSpend + lovelacesAdjustAmt
       })
     },
-    (0, import_lucid46.addAssets)(
+    (0, import_lucid48.addAssets)(
       lrpUtxo.assets,
       mkAssetsOf(rewardAssetClass, -rewardAssetsAmt),
       mkLovelacesOf(lovelacesAdjustAmt)
     )
   ).addSignerKey(lrpDatum.owner);
 }
-async function claimLrp(lucid, lrpOutRef, lrpRefScriptOutRef, lrpParams) {
-  return adjustLrp(lucid, lrpOutRef, 0n, lrpRefScriptOutRef, lrpParams);
+async function claimLrp(lucid, lrpOutRef, sysParams) {
+  return adjustLrp(lucid, lrpOutRef, 0n, sysParams);
 }
 
 // src/contracts/lrp/scripts.ts
-var import_lucid47 = require("@lucid-evolution/lucid");
+var import_lucid49 = require("@lucid-evolution/lucid");
 
 // src/validators/lrp-validator.ts
 var _lrpValidator = {
@@ -5403,13 +5691,13 @@ var _lrpValidator = {
 var mkLrpValidator = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid47.applyParamsToScript)(_lrpValidator.cborHex, [castLrpParams(params)])
+    script: (0, import_lucid49.applyParamsToScript)(_lrpValidator.cborHex, [castLrpParams(params)])
   };
 };
 var mkLrpValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
-    script: (0, import_lucid47.applyParamsToScript)(_lrpValidator.cborHex, [
+    script: (0, import_lucid49.applyParamsToScript)(_lrpValidator.cborHex, [
       castLrpParams({
         versionRecordToken: fromSystemParamsAsset(params.versionRecordToken),
         iassetNft: fromSystemParamsAsset(params.iassetNft),
@@ -5421,7 +5709,7 @@ var mkLrpValidatorFromSP = (params) => {
 };
 
 // src/utils/helper-txs.ts
-var import_lucid48 = require("@lucid-evolution/lucid");
+var import_lucid50 = require("@lucid-evolution/lucid");
 
 // src/scripts/always-fail-validator.ts
 var alwaysFailValidator = {
@@ -5431,11 +5719,367 @@ var alwaysFailValidator = {
 
 // src/utils/helper-txs.ts
 async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
-  const scriptAddr = (0, import_lucid48.validatorToAddress)(network, alwaysFailValidator);
+  const scriptAddr = (0, import_lucid50.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/leverage/transactions.ts
+var import_lucid51 = require("@lucid-evolution/lucid");
+
+// src/contracts/leverage/helpers.ts
+var import_fp_ts14 = require("fp-ts");
+var import_decimal2 = require("decimal.js");
+var MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+function approximateLeverageRedemptions(baseCollateral, targetLeverage, redemptionReimbursementPercentage, debtMintingFeePercentage) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal2.Decimal)(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = (0, import_decimal2.Decimal)(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const bExFees = (0, import_decimal2.Decimal)(baseCollateral).mul(targetLeverage).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = {
+    getOnChainInt: fromDecimal(
+      (0, import_decimal2.Decimal)((0, import_decimal2.Decimal)(baseCollateral).add(bExFees)).div(b).mul(100n * OCD_DECIMAL_UNIT).floor()
+    )
+  };
+  return {
+    leverage: targetLeverage,
+    collateralRatio,
+    lovelacesForRedemptionWithReimbursement: fromDecimal(b)
+  };
+}
+function summarizeActualLeverageRedemptions(lovelacesForRedemptionWithReimbursement, redemptionReimbursementPercentage, iassetPrice, lrpParams, redemptionLrps) {
+  const priceDecimal = (0, import_decimal2.Decimal)(iassetPrice.getOnChainInt).div(OCD_DECIMAL_UNIT);
+  const redemptionDetails = import_fp_ts14.function.pipe(
+    redemptionLrps,
+    import_fp_ts14.array.reduce(
+      {
+        remainingRedemptionLovelacesInclReim: lovelacesForRedemptionWithReimbursement,
+        redemptions: []
+      },
+      (acc, lrp) => {
+        if (acc.remainingRedemptionLovelacesInclReim < lrpParams.minRedemptionLovelacesAmt) {
+          return acc;
+        }
+        const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
+          lrp,
+          lrpParams
+        );
+        if (lovelacesToSpend === 0n) {
+          return acc;
+        }
+        const newRemainingLovelaces = bigintMax(
+          acc.remainingRedemptionLovelacesInclReim - lovelacesToSpend,
+          0n
+        );
+        const redemptionLovelacesInitial = acc.remainingRedemptionLovelacesInclReim - newRemainingLovelaces;
+        const finalRedemptionIAssets = fromDecimal(
+          (0, import_decimal2.Decimal)(redemptionLovelacesInitial).div(priceDecimal).floor()
+        );
+        const finalRedemptionLovelaces = ocdMul(
+          {
+            getOnChainInt: finalRedemptionIAssets
+          },
+          iassetPrice
+        ).getOnChainInt;
+        const reimbursementLovelaces = calculateFeeFromPercentage(
+          redemptionReimbursementPercentage,
+          finalRedemptionLovelaces
+        );
+        return {
+          remainingRedemptionLovelacesInclReim: acc.remainingRedemptionLovelacesInclReim - finalRedemptionLovelaces,
+          redemptions: [
+            ...acc.redemptions,
+            {
+              utxo: lrp[0],
+              iassetsForRedemptionAmt: finalRedemptionIAssets,
+              redemptionLovelacesAmtInclReimbursement: finalRedemptionLovelaces,
+              reimbursementLovelacesAmt: reimbursementLovelaces
+            }
+          ]
+        };
+      }
+    )
+  );
+  const res = import_fp_ts14.function.pipe(
+    redemptionDetails.redemptions,
+    import_fp_ts14.array.reduce(
+      {
+        redeemedLovelaces: 0n,
+        redemptionIAssets: 0n,
+        reimbursementLovelaces: 0n
+      },
+      (acc, details) => {
+        return {
+          redeemedLovelaces: acc.redeemedLovelaces + details.redemptionLovelacesAmtInclReimbursement - details.reimbursementLovelacesAmt,
+          reimbursementLovelaces: acc.reimbursementLovelaces + details.reimbursementLovelacesAmt,
+          redemptionIAssets: acc.redemptionIAssets + details.iassetsForRedemptionAmt
+        };
+      }
+    )
+  );
+  return {
+    redemptions: redemptionDetails.redemptions,
+    totalRedeemedLovelaces: res.redeemedLovelaces,
+    totalReimbursementLovelaces: res.reimbursementLovelaces,
+    totalRedemptionIAssets: res.redemptionIAssets
+  };
+}
+function calculateCollateralRatioFromLeverage(iasset, leverage, baseCollateral, iassetPrice, debtMintingFeePercentage, redemptionReimbursementPercentage, lrpParams, allLrps) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal2.Decimal)(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = (0, import_decimal2.Decimal)(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const maxAvailableAdaForRedemptionInclReimb = calculateTotalAdaForRedemption(
+    iasset,
+    iassetPrice,
+    lrpParams,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (leverage <= 1 || baseCollateral <= 0n || maxAvailableAdaForRedemptionInclReimb <= 0n) {
+    return void 0;
+  }
+  const bExFees = (0, import_decimal2.Decimal)(baseCollateral).mul(leverage).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableAdaForRedemptionInclReimb,
+    fromDecimal(b)
+  );
+  const cappedBExFees = (0, import_decimal2.Decimal)(cappedB).mul((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = (0, import_decimal2.Decimal)(
+    (0, import_decimal2.Decimal)(baseCollateral).add(cappedBExFees)
+  ).div(cappedB);
+  return {
+    getOnChainInt: fromDecimal(
+      collateralRatio.mul(100n * OCD_DECIMAL_UNIT).floor()
+    )
+  };
+}
+function calculateLeverageFromCollateralRatio(iasset, collateralRatioPercentage, baseCollateral, iassetPrice, debtMintingFeePercentage, redemptionReimbursementPercentage, lrpParams, allLrps) {
+  const debtMintingFeeRatioDecimal = (0, import_decimal2.Decimal)(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = (0, import_decimal2.Decimal)(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const collateralRatio = (0, import_decimal2.Decimal)(collateralRatioPercentage.getOnChainInt).div(OCD_DECIMAL_UNIT).div(100);
+  const maxAvailableAdaForRedemptionInclReimb = calculateTotalAdaForRedemption(
+    iasset,
+    iassetPrice,
+    lrpParams,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (collateralRatio.toNumber() <= 1 || baseCollateral <= 0n || maxAvailableAdaForRedemptionInclReimb <= 0n) {
+    return void 0;
+  }
+  const theoreticalMaxLeverage = (0, import_decimal2.Decimal)((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).div(collateralRatio.minus(1).add(totalFeeRatio)).add(1);
+  const bExFees = theoreticalMaxLeverage.mul(baseCollateral).minus(baseCollateral).floor();
+  const b = bExFees.div((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableAdaForRedemptionInclReimb,
+    fromDecimal(b)
+  );
+  const cappedBExFees = (0, import_decimal2.Decimal)(cappedB).mul((0, import_decimal2.Decimal)(1).minus(totalFeeRatio)).floor();
+  return (0, import_decimal2.Decimal)(baseCollateral).add(cappedBExFees).div(baseCollateral).toNumber();
+}
+
+// src/contracts/leverage/transactions.ts
+async function leverageCdpWithLrp(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, cdpCreatorOref, interestOracleOref, collectorOref, sysParams, lucid, allLrps, currentSlot) {
+  const network = lucid.config().network;
+  const currentTime = BigInt((0, import_lucid51.slotToUnixTime)(network, currentSlot));
+  const [pkh, skh] = await addrDetails(lucid);
+  const lrpScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.lrpValidatorRef)
+    ]),
+    (_) => new Error("Expected a single LRP Ref Script UTXO")
+  );
+  const cdpCreatorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.cdpCreatorValidatorRef
+      )
+    ]),
+    (_) => new Error("Expected a single cdp creator Ref Script UTXO")
+  );
+  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef
+      )
+    ]),
+    (_) => new Error("Expected a single cdp auth token policy Ref Script UTXO")
+  );
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.iAssetTokenPolicyRef
+      )
+    ]),
+    (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
+  );
+  const cdpCreatorUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpCreatorOref]),
+    (_) => new Error("Expected a single CDP creator UTXO")
+  );
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_) => new Error("Expected a single interest oracle UTXO")
+  );
+  const interestOracleDatum = parseInterestOracleDatum(
+    getInlineDatumOrThrow(interestOracleUtxo)
+  );
+  const priceOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([priceOracleOutRef]),
+    (_) => new Error("Expected a single price oracle UTXO")
+  );
+  const priceOracleDatum = parsePriceOracleDatum(
+    getInlineDatumOrThrow(priceOracleUtxo)
+  );
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOutRef]),
+    (_) => new Error("Expected a single IAsset UTXO")
+  );
+  const iassetDatum = parseIAssetDatumOrThrow(
+    getInlineDatumOrThrow(iassetUtxo)
+  );
+  const maxLeverage = calculateLeverageFromCollateralRatio(
+    iassetDatum.assetName,
+    iassetDatum.maintenanceRatio,
+    baseCollateral,
+    priceOracleDatum.price,
+    iassetDatum.debtMintingFeePercentage,
+    iassetDatum.redemptionReimbursementPercentage,
+    sysParams.lrpParams,
+    allLrps
+  );
+  if (!maxLeverage) {
+    throw new Error("Can't calculate max leverage with those parameters.");
+  }
+  const leverageSummary = approximateLeverageRedemptions(
+    baseCollateral,
+    leverage,
+    iassetDatum.redemptionReimbursementPercentage,
+    iassetDatum.debtMintingFeePercentage
+  );
+  if (maxLeverage < leverageSummary.leverage) {
+    throw new Error("Can't use more leverage than max.");
+  }
+  if (leverageSummary.collateralRatio.getOnChainInt < iassetDatum.maintenanceRatio.getOnChainInt) {
+    throw new Error(
+      "Can't have collateral ratio smaller than maintenance ratio"
+    );
+  }
+  const redemptionDetails = summarizeActualLeverageRedemptions(
+    leverageSummary.lovelacesForRedemptionWithReimbursement,
+    iassetDatum.redemptionReimbursementPercentage,
+    priceOracleDatum.price,
+    sysParams.lrpParams,
+    randomLrpsSubsetSatisfyingTargetLovelaces(
+      iassetDatum.assetName,
+      leverageSummary.lovelacesForRedemptionWithReimbursement,
+      priceOracleDatum.price,
+      allLrps,
+      sysParams.lrpParams,
+      MAX_REDEMPTIONS_WITH_CDP_OPEN
+    )
+  );
+  const mintedAmt = redemptionDetails.totalRedemptionIAssets;
+  const debtMintingFee = calculateFeeFromPercentage(
+    iassetDatum.debtMintingFeePercentage,
+    ocdMul({ getOnChainInt: mintedAmt }, priceOracleDatum.price).getOnChainInt
+  );
+  const collateralAmt = redemptionDetails.totalRedeemedLovelaces + baseCollateral - debtMintingFee;
+  const cdpNftVal = mkAssetsOf(
+    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    1n
+  );
+  const iassetTokensVal = mkAssetsOf(
+    {
+      currencySymbol: sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol,
+      tokenName: iassetDatum.assetName
+    },
+    mintedAmt
+  );
+  const txValidity = oracleExpirationAwareValidity(
+    currentSlot,
+    Number(sysParams.cdpCreatorParams.biasTime),
+    Number(priceOracleDatum.expiration),
+    network
+  );
+  const tx = lucid.newTx().validFrom(txValidity.validFrom).validTo(txValidity.validTo).readFrom([priceOracleUtxo, interestOracleUtxo, iassetUtxo]).readFrom([
+    cdpCreatorRefScriptUtxo,
+    cdpAuthTokenPolicyRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+    lrpScriptRefUtxo
+  ]).mintAssets(cdpNftVal, import_lucid51.Data.void()).mintAssets(iassetTokensVal, import_lucid51.Data.void()).collectFrom(
+    [cdpCreatorUtxo],
+    serialiseCDPCreatorRedeemer({
+      CreateCDP: {
+        cdpOwner: pkh.hash,
+        minted: mintedAmt,
+        collateral: collateralAmt,
+        currentTime
+      }
+    })
+  ).pay.ToContract(
+    createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
+    {
+      kind: "inline",
+      value: serialiseCdpDatum({
+        cdpOwner: pkh.hash,
+        iasset: iassetDatum.assetName,
+        mintedAmt,
+        cdpFees: {
+          ActiveCDPInterestTracking: {
+            lastSettled: currentTime,
+            unitaryInterestSnapshot: calculateUnitaryInterestSinceOracleLastUpdated(
+              currentTime,
+              interestOracleDatum
+            ) + interestOracleDatum.unitaryInterest
+          }
+        }
+      })
+    },
+    (0, import_lucid51.addAssets)(cdpNftVal, mkLovelacesOf(collateralAmt))
+  ).pay.ToContract(
+    cdpCreatorUtxo.address,
+    { kind: "inline", value: import_lucid51.Data.void() },
+    cdpCreatorUtxo.assets
+  ).addSignerKey(pkh.hash);
+  buildRedemptionsTx(
+    redemptionDetails.redemptions.map((r) => [
+      r.utxo,
+      r.iassetsForRedemptionAmt
+    ]),
+    priceOracleDatum.price,
+    iassetDatum.redemptionReimbursementPercentage,
+    sysParams,
+    tx,
+    2n
+  );
+  if (debtMintingFee > 0) {
+    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collectorOref);
+  }
+  return tx;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccountContentSchema,
@@ -5464,6 +6108,8 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   LRPDatumSchema,
   LRPParamsSchema,
   LRPRedeemerSchema,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN,
+  MIN_LRP_COLLATERAL_AMT,
   ONE_DAY,
   ONE_HOUR,
   ONE_SECOND,
@@ -5494,12 +6140,17 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   adjustSpAccount,
   adjustStakingPosition,
   adjustmentHelper,
+  approximateLeverageRedemptions,
   assetClassToUnit,
   assetClassValueOf,
   balance,
+  buildRedemptionsTx,
   burnCdp,
+  calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalAdaForRedemption,
   cancelLrp,
   castCDPCreatorParams,
   castCdpParams,
@@ -5511,6 +6162,7 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   castPollShardParams,
   castPriceOracleParams,
   castStabilityPoolParams,
+  castStakingParams,
   castVersionRecordTokenParams,
   cdpCollateralRatioPercentage,
   claimLrp,
@@ -5523,6 +6175,7 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   createShardsChunks,
   createSpAccount,
   depositCdp,
+  distributeAda,
   endProposal,
   executeProposal,
   feedInterestOracle,
@@ -5538,12 +6191,15 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   getSumFromEpochToScaleToSum,
   initEpochToScaleToSumMap,
   initSpSnapshot,
+  insertSorted,
   isAssetsZero,
+  leverageCdpWithLrp,
   liquidateCdp,
   liquidationHelper,
   loadSystemParamsFromFile,
   loadSystemParamsFromUrl,
   lovelacesAmt,
+  lrpRedeemableLovelacesInclReimb,
   matchSingle,
   mergeCdps,
   mergeShards,
@@ -5583,10 +6239,15 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   parseIAssetDatumOrThrow,
   parseInterestOracleDatum,
   parseLrpDatum,
+  parseLrpDatumOrThrow,
   parsePriceOracleDatum,
   parseSnapshotEpochToScaleToSumDatum,
   parseStabilityPoolDatum,
+  parseStakingManagerDatum,
+  parseStakingPosition,
+  parseStakingPositionOrThrow,
   processSpRequest,
+  randomLrpsSubsetSatisfyingTargetLovelaces,
   redeemCdp,
   redeemLrp,
   runCreateScriptRefTx,
@@ -5610,12 +6271,16 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   serialisePriceOracleRedeemer,
   serialiseStabilityPoolDatum,
   serialiseStabilityPoolRedeemer,
+  serialiseStakingDatum,
+  serialiseStakingRedeemer,
   setSumInEpochToScaleToSum,
+  shuffle,
   spAdd,
   spDiv,
   spMul,
   spSub,
   startInterestOracle,
+  summarizeActualLeverageRedemptions,
   toSystemParamsAsset,
   treasuryFeeTx,
   updatePoolSnapshotWithdrawalFee,