@indigo-labs/indigo-sdk 0.2.2 → 0.2.4

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/contracts/cdp/transactions.ts
 import {
   addAssets as addAssets3,
-  Data as Data12,
+  Data as Data13,
   slotToUnixTime as slotToUnixTime3
 } from "@lucid-evolution/lucid";
 
@@ -805,12 +805,23 @@ function calculateMinCollateralCappedIAssetRedemptionAmt(collateralAmt, mintedAm
 }
 
 // src/utils/bigint-utils.ts
+import { array as A } from "fp-ts";
 function bigintMax(a, b) {
   return a > b ? a : b;
 }
 function bigintMin(a, b) {
   return a < b ? a : b;
 }
+function sum(arr) {
+  return A.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
 import { Core as EvoCore2 } from "@evolution-sdk/evolution";
@@ -986,14 +997,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) {
@@ -1167,13 +1178,26 @@ function liquidationHelper(spContent, iassetBurnAmt, reward) {
 }
 
 // src/contracts/cdp/transactions.ts
-import { array as A, function as F3 } from "fp-ts";
+import { array as A2, function as F3 } from "fp-ts";
 
 // src/contracts/collector/transactions.ts
 import {
-  Constr,
-  Data as Data9
+  Data as Data10
 } from "@lucid-evolution/lucid";
+
+// src/contracts/collector/types.ts
+import { Data as Data9 } from "@lucid-evolution/lucid";
+var CollectorRedeemerSchema = Data9.Enum([
+  Data9.Literal("Collect"),
+  Data9.Literal("DistributeToStakers"),
+  Data9.Literal("UpgradeVersion")
+]);
+var CollectorRedeemer = CollectorRedeemerSchema;
+function serialiseCollectorRedeemer(redeemer) {
+  return Data9.to(redeemer, CollectorRedeemer);
+}
+
+// src/contracts/collector/transactions.ts
 async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   const collectorUtxo = matchSingle(
     await lucid.utxosByOutRef([collectorOref]),
@@ -1185,9 +1209,9 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
     ]),
     (_) => new Error("Expected a single collector Ref Script UTXO")
   );
-  tx.collectFrom([collectorUtxo], Data9.to(new Constr(0, []))).pay.ToContract(
+  tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
-    { kind: "inline", value: Data9.to(new Constr(0, [])) },
+    { kind: "inline", value: Data10.void() },
     {
       ...collectorUtxo.assets,
       lovelace: collectorUtxo.assets.lovelace + fee
@@ -1198,35 +1222,35 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
 // src/contracts/treasury/transactions.ts
 import {
   addAssets as addAssets2,
-  Data as Data11
+  Data as Data12
 } from "@lucid-evolution/lucid";
 
 // src/contracts/treasury/types.ts
-import { Data as Data10 } from "@lucid-evolution/lucid";
-var TreasuryParamsSchema = Data10.Object({
+import { Data as Data11 } from "@lucid-evolution/lucid";
+var TreasuryParamsSchema = Data11.Object({
   upgradeToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  treasuryUtxosStakeCredential: Data10.Nullable(StakeCredentialSchema)
+  treasuryUtxosStakeCredential: Data11.Nullable(StakeCredentialSchema)
 });
-var TreasuryRedeemerSchema = Data10.Enum([
-  Data10.Literal("Withdraw"),
-  Data10.Literal("PrepareWithdraw"),
-  Data10.Literal("Split"),
-  Data10.Literal("Merge"),
-  Data10.Literal("CollectAda"),
-  Data10.Literal("UpgradeVersion")
+var TreasuryRedeemerSchema = Data11.Enum([
+  Data11.Literal("Withdraw"),
+  Data11.Literal("PrepareWithdraw"),
+  Data11.Literal("Split"),
+  Data11.Literal("Merge"),
+  Data11.Literal("CollectAda"),
+  Data11.Literal("UpgradeVersion")
 ]);
 var TreasuryRedeemer = TreasuryRedeemerSchema;
-var WithdrawalOutputDatumSchema = Data10.Tuple([
-  Data10.Bytes(),
+var WithdrawalOutputDatumSchema = Data11.Tuple([
+  Data11.Bytes(),
   OutputReferenceSchema
 ]);
 var WithdrawalOutputDatum = WithdrawalOutputDatumSchema;
 function serialiseWithdrawalOutputDatum(d) {
-  return Data10.to(d, WithdrawalOutputDatum);
+  return Data11.to(d, WithdrawalOutputDatum);
 }
 function serialiseTreasuryRedeemer(redeemer) {
-  return Data10.to(redeemer, TreasuryRedeemer);
+  return Data11.to(redeemer, TreasuryRedeemer);
 }
 
 // src/contracts/treasury/transactions.ts
@@ -1245,7 +1269,7 @@ async function treasuryFeeTx(fee, lucid, sysParams, tx, treasuryOref) {
   );
   tx.readFrom([treasuryRefScriptUtxo]).collectFrom([treasuryUtxo], serialiseTreasuryRedeemer("CollectAda")).pay.ToContract(
     treasuryUtxo.address,
-    { kind: "inline", value: Data11.void() },
+    { kind: "inline", value: Data12.void() },
     addAssets2(treasuryUtxo.assets, mkLovelacesOf(fee))
   );
 }
@@ -1329,7 +1353,7 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     cdpCreatorRefScriptUtxo,
     cdpAuthTokenPolicyRefScriptUtxo,
     iAssetTokenPolicyRefScriptUtxo
-  ]).mintAssets(cdpNftVal, Data12.void()).mintAssets(iassetTokensVal, Data12.void()).collectFrom(
+  ]).mintAssets(cdpNftVal, Data13.void()).mintAssets(iassetTokensVal, Data13.void()).collectFrom(
     [cdpCreatorUtxo],
     serialiseCDPCreatorRedeemer({
       CreateCDP: {
@@ -1361,7 +1385,7 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     addAssets3(cdpNftVal, mkLovelacesOf(collateralAmount))
   ).pay.ToContract(
     cdpCreatorUtxo.address,
-    { kind: "inline", value: Data12.void() },
+    { kind: "inline", value: Data13.void() },
     cdpCreatorUtxo.assets
   ).readFrom([priceOracleUtxo, interestOracleUtxo, iassetUtxo]).addSignerKey(pkh.hash);
   const debtMintingFee = calculateFeeFromPercentage(
@@ -1474,7 +1498,7 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
     );
     tx.readFrom([iAssetTokenPolicyRefScriptUtxo]).mintAssets(
       iassetTokensVal,
-      Data12.void()
+      Data13.void()
     );
   }
   const interestAdaAmt = match7(cdpDatum.cdpFees).with({ FrozenCDPAccumulatedFees: P6.any }, () => {
@@ -1659,10 +1683,10 @@ async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref
       },
       -cdpDatum.mintedAmt
     ),
-    Data12.void()
+    Data13.void()
   ).mintAssets(
     mkAssetsOf(fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken), -1n),
-    Data12.void()
+    Data13.void()
   ).collectFrom(
     [cdpUtxo],
     serialiseCdpRedeemer({ CloseCdp: { currentTime } })
@@ -1817,7 +1841,7 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
       },
       -redemptionIAssetAmt
     ),
-    Data12.void()
+    Data13.void()
   ).pay.ToContract(
     cdpUtxo.address,
     {
@@ -2027,7 +2051,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
     stabilityPoolRefScriptUtxo,
     iAssetTokenPolicyRefScriptUtxo,
     cdpAuthTokenPolicyRefScriptUtxo
-  ]).collectFrom([spUtxo], serialiseStabilityPoolRedeemer("LiquidateCDP")).collectFrom([cdpUtxo], serialiseCdpRedeemer("Liquidate")).mintAssets(mkAssetsOf(iassetsAc, -iassetBurnAmt), Data12.void()).pay.ToContract(
+  ]).collectFrom([spUtxo], serialiseStabilityPoolRedeemer("LiquidateCDP")).collectFrom([cdpUtxo], serialiseCdpRedeemer("Liquidate")).mintAssets(mkAssetsOf(iassetsAc, -iassetBurnAmt), Data13.void()).pay.ToContract(
     spUtxo.address,
     {
       kind: "inline",
@@ -2069,7 +2093,7 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
   } else {
     tx.mintAssets(
       mkAssetsOf(cdpNftAc, -assetClassValueOf(cdpUtxo.assets, cdpNftAc)),
-      Data12.void()
+      Data13.void()
     );
   }
   await collectorFeeTx(
@@ -2098,15 +2122,15 @@ async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
   }
   const aggregatedVal = F3.pipe(
     cdpUtxos,
-    A.reduce({}, (acc, utxo) => addAssets3(acc, utxo.assets))
+    A2.reduce({}, (acc, utxo) => addAssets3(acc, utxo.assets))
   );
   const aggregatedMintedAmt = F3.pipe(
     cdpDatums,
-    A.reduce(0n, (acc, cdpDat) => acc + cdpDat.mintedAmt)
+    A2.reduce(0n, (acc, cdpDat) => acc + cdpDat.mintedAmt)
   );
   const { aggregatedFeeTreasury, aggregatedFeeIndyStakers } = F3.pipe(
     cdpDatums,
-    A.reduce(
+    A2.reduce(
       { aggregatedFeeIndyStakers: 0n, aggregatedFeeTreasury: 0n },
       (acc, cdpDat) => match7(cdpDat.cdpFees).returnType().with({ FrozenCDPAccumulatedFees: P6.select() }, (fees) => ({
         aggregatedFeeIndyStakers: acc.aggregatedFeeIndyStakers + fees.lovelacesIndyStakers,
@@ -2115,7 +2139,7 @@ async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
     )
   );
   const [[mainMergeUtxo, mainCdpDatum], otherMergeUtxos] = match7(
-    A.zip(cdpUtxos, cdpDatums)
+    A2.zip(cdpUtxos, cdpDatums)
   ).returnType().with([P6._, ...P6.array()], ([main, ...other]) => [
     main,
     other.map((a) => a[0])
@@ -2232,61 +2256,61 @@ var mkCDPCreatorValidatorFromSP = (params) => {
 import { applyParamsToScript as applyParamsToScript3 } from "@lucid-evolution/lucid";
 
 // src/contracts/poll/types-poll-manager.ts
-import { Data as Data13 } from "@lucid-evolution/lucid";
-var PollManagerParamsSchema = Data13.Object({
+import { Data as Data14 } from "@lucid-evolution/lucid";
+var PollManagerParamsSchema = Data14.Object({
   govNFT: AssetClassSchema,
   pollToken: AssetClassSchema,
   upgradeToken: AssetClassSchema,
   indyAsset: AssetClassSchema,
-  govExecuteValHash: Data13.Bytes(),
-  pBiasTime: Data13.Integer(),
-  shardValHash: Data13.Bytes(),
-  treasuryValHash: Data13.Bytes(),
-  initialIndyDistribution: Data13.Integer()
+  govExecuteValHash: Data14.Bytes(),
+  pBiasTime: Data14.Integer(),
+  shardValHash: Data14.Bytes(),
+  treasuryValHash: Data14.Bytes(),
+  initialIndyDistribution: Data14.Integer()
 });
 var PollManagerParams = PollManagerParamsSchema;
-var PollManagerRedeemerSchema = Data13.Enum([
-  Data13.Object({
-    EndPoll: Data13.Object({ currentTime: Data13.Integer() })
+var PollManagerRedeemerSchema = Data14.Enum([
+  Data14.Object({
+    EndPoll: Data14.Object({ currentTime: Data14.Integer() })
   }),
-  Data13.Object({ CreateShards: Data13.Object({ currentTime: Data13.Integer() }) }),
-  Data13.Object({
-    MergeShardsManager: Data13.Object({ currentTime: Data13.Integer() })
+  Data14.Object({ CreateShards: Data14.Object({ currentTime: Data14.Integer() }) }),
+  Data14.Object({
+    MergeShardsManager: Data14.Object({ currentTime: Data14.Integer() })
   })
 ]);
 var PollManagerRedeemer = PollManagerRedeemerSchema;
 function serialisePollManagerRedeemer(r) {
-  return Data13.to(r, PollManagerRedeemer);
+  return Data14.to(r, PollManagerRedeemer);
 }
 function castPollManagerParams(params) {
-  return Data13.castTo(params, PollManagerParams);
+  return Data14.castTo(params, PollManagerParams);
 }
 
 // src/contracts/poll/types-poll-shard.ts
-import { Data as Data14 } from "@lucid-evolution/lucid";
-var PollShardParamsSchema = Data14.Object({
+import { Data as Data15 } from "@lucid-evolution/lucid";
+var PollShardParamsSchema = Data15.Object({
   pollToken: AssetClassSchema,
   stakingToken: AssetClassSchema,
   indyAsset: AssetClassSchema,
-  stakingValHash: Data14.Bytes()
+  stakingValHash: Data15.Bytes()
 });
 var PollShardParams = PollShardParamsSchema;
-var VoteOptionSchema = Data14.Enum([Data14.Literal("Yes"), Data14.Literal("No")]);
-var PollShardRedeemerSchema = Data14.Enum([
-  Data14.Object({ Vote: Data14.Object({ content: VoteOptionSchema }) }),
-  Data14.Object({
-    MergeShards: Data14.Object({
-      currentTime: Data14.Integer(),
+var VoteOptionSchema = Data15.Enum([Data15.Literal("Yes"), Data15.Literal("No")]);
+var PollShardRedeemerSchema = Data15.Enum([
+  Data15.Object({ Vote: Data15.Object({ content: VoteOptionSchema }) }),
+  Data15.Object({
+    MergeShards: Data15.Object({
+      currentTime: Data15.Integer(),
       pollManagerRef: OutputReferenceSchema
     })
   })
 ]);
 var PollShardRedeemer = PollShardRedeemerSchema;
 function serialisePollShardRedeemer(redeemer) {
-  return Data14.to(redeemer, PollShardRedeemer);
+  return Data15.to(redeemer, PollShardRedeemer);
 }
 function castPollShardParams(params) {
-  return Data14.castTo(params, PollShardParams);
+  return Data15.castTo(params, PollShardParams);
 }
 
 // src/validators/poll-manager-validator.ts
@@ -2363,44 +2387,44 @@ import {
 } from "@lucid-evolution/lucid";
 
 // src/contracts/poll/types-poll.ts
-import { Data as Data15 } from "@lucid-evolution/lucid";
+import { Data as Data16 } from "@lucid-evolution/lucid";
 import { option as O3, function as F4 } from "fp-ts";
 import { match as match8, P as P7 } from "ts-pattern";
-var PollStatusSchema = Data15.Object({
-  yesVotes: Data15.Integer(),
-  noVotes: Data15.Integer()
+var PollStatusSchema = Data16.Object({
+  yesVotes: Data16.Integer(),
+  noVotes: Data16.Integer()
 });
-var PollManagerContentSchema = Data15.Object({
-  pollId: Data15.Integer(),
-  pollOwner: Data15.Bytes(),
+var PollManagerContentSchema = Data16.Object({
+  pollId: Data16.Integer(),
+  pollOwner: Data16.Bytes(),
   content: ProposalContentSchema,
-  treasuryWithdrawal: Data15.Nullable(TreasuryWithdrawalSchema),
+  treasuryWithdrawal: Data16.Nullable(TreasuryWithdrawalSchema),
   status: PollStatusSchema,
-  votingEndTime: Data15.Integer(),
-  createdShardsCount: Data15.Integer(),
-  talliedShardsCount: Data15.Integer(),
-  totalShardsCount: Data15.Integer(),
-  proposingEndTime: Data15.Integer(),
-  expirationTime: Data15.Integer(),
-  protocolVersion: Data15.Integer(),
-  minimumQuorum: Data15.Integer()
+  votingEndTime: Data16.Integer(),
+  createdShardsCount: Data16.Integer(),
+  talliedShardsCount: Data16.Integer(),
+  totalShardsCount: Data16.Integer(),
+  proposingEndTime: Data16.Integer(),
+  expirationTime: Data16.Integer(),
+  protocolVersion: Data16.Integer(),
+  minimumQuorum: Data16.Integer()
 });
-var PollShardContentSchema = Data15.Object({
-  pollId: Data15.Integer(),
+var PollShardContentSchema = Data16.Object({
+  pollId: Data16.Integer(),
   status: PollStatusSchema,
-  votingEndTime: Data15.Integer(),
+  votingEndTime: Data16.Integer(),
   managerAddress: AddressSchema
 });
-var PollDatumSchema = Data15.Enum([
-  Data15.Object({
-    PollManager: Data15.Object({ content: PollManagerContentSchema })
+var PollDatumSchema = Data16.Enum([
+  Data16.Object({
+    PollManager: Data16.Object({ content: PollManagerContentSchema })
   }),
-  Data15.Object({ PollShard: Data15.Object({ content: PollShardContentSchema }) })
+  Data16.Object({ PollShard: Data16.Object({ content: PollShardContentSchema }) })
 ]);
 var PollDatum = PollDatumSchema;
 function parsePollManager(datum) {
   try {
-    return match8(Data15.from(datum, PollDatum)).with({ PollManager: P7.select() }, (res) => O3.some(res.content)).otherwise(() => O3.none);
+    return match8(Data16.from(datum, PollDatum)).with({ PollManager: P7.select() }, (res) => O3.some(res.content)).otherwise(() => O3.none);
   } catch (_) {
     return O3.none;
   }
@@ -2415,7 +2439,7 @@ function parsePollManagerOrThrow(datum) {
 }
 function parsePollShard(datum) {
   try {
-    return match8(Data15.from(datum, PollDatum)).with({ PollShard: P7.select() }, (res) => O3.some(res.content)).otherwise(() => O3.none);
+    return match8(Data16.from(datum, PollDatum)).with({ PollShard: P7.select() }, (res) => O3.some(res.content)).otherwise(() => O3.none);
   } catch (_) {
     return O3.none;
   }
@@ -2429,49 +2453,49 @@ function parsePollShardOrThrow(datum) {
   );
 }
 function serialisePollDatum(datum) {
-  return Data15.to(datum, PollDatum);
+  return Data16.to(datum, PollDatum);
 }
 
 // src/contracts/gov/transactions.ts
-import { Data as Data18 } from "@lucid-evolution/lucid";
+import { Data as Data19 } from "@lucid-evolution/lucid";
 import { pipe as pipe2 } from "fp-ts/lib/function";
-import { array as A4, option as O7, function as F8 } from "fp-ts";
+import { array as A5, option as O7, function as F8 } from "fp-ts";
 import { match as match11, P as P10 } from "ts-pattern";
 
 // src/contracts/staking/types.ts
-import { Data as Data16 } from "@lucid-evolution/lucid";
-var StakingParamsSchema = Data16.Object({
+import { Data as Data17 } from "@lucid-evolution/lucid";
+var StakingParamsSchema = Data17.Object({
   stakingManagerNft: AssetClassSchema,
   stakingToken: AssetClassSchema,
   indyToken: AssetClassSchema,
   pollToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  collectorValHash: Data16.Bytes()
+  collectorValHash: Data17.Bytes()
 });
 var StakingParams = StakingParamsSchema;
-var StakingRedeemerSchema = Data16.Enum([
-  Data16.Object({
-    CreateStakingPosition: Data16.Object({
-      creatorPkh: Data16.Bytes()
+var StakingRedeemerSchema = Data17.Enum([
+  Data17.Object({
+    CreateStakingPosition: Data17.Object({
+      creatorPkh: Data17.Bytes()
     })
   }),
-  Data16.Literal("UpdateTotalStake"),
-  Data16.Literal("Distribute"),
-  Data16.Object({
-    AdjustStakedAmount: Data16.Object({
-      adjustAmount: Data16.Integer()
+  Data17.Literal("UpdateTotalStake"),
+  Data17.Literal("Distribute"),
+  Data17.Object({
+    AdjustStakedAmount: Data17.Object({
+      adjustAmount: Data17.Integer()
     })
   }),
-  Data16.Literal("Unstake"),
-  Data16.Literal("Lock"),
-  Data16.Literal("UpgradeVersion")
+  Data17.Literal("Unstake"),
+  Data17.Literal("Lock"),
+  Data17.Literal("UpgradeVersion")
 ]);
 var StakingRedeemer = StakingRedeemerSchema;
 function serialiseStakingRedeemer(redeemer) {
-  return Data16.to(redeemer, StakingRedeemer);
+  return Data17.to(redeemer, StakingRedeemer);
 }
 function castStakingParams(params) {
-  return Data16.castTo(params, StakingParams);
+  return Data17.castTo(params, StakingParams);
 }
 
 // src/contracts/staking/types-new.ts
@@ -2547,7 +2571,7 @@ import {
 // src/contracts/staking/scripts.ts
 import {
   applyParamsToScript as applyParamsToScript4,
-  Constr as Constr2,
+  Constr,
   fromText as fromText2
 } from "@lucid-evolution/lucid";
 
@@ -2563,24 +2587,24 @@ var mkStakingValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
     script: applyParamsToScript4(_stakingValidator.cborHex, [
-      new Constr2(0, [
-        new Constr2(0, [
+      new Constr(0, [
+        new Constr(0, [
           params.stakingManagerNFT[0].unCurrencySymbol,
           fromText2(params.stakingManagerNFT[1].unTokenName)
         ]),
-        new Constr2(0, [
+        new Constr(0, [
           params.stakingToken[0].unCurrencySymbol,
           fromText2(params.stakingToken[1].unTokenName)
         ]),
-        new Constr2(0, [
+        new Constr(0, [
           params.indyToken[0].unCurrencySymbol,
           fromText2(params.indyToken[1].unTokenName)
         ]),
-        new Constr2(0, [
+        new Constr(0, [
           params.pollToken[0].unCurrencySymbol,
           fromText2(params.pollToken[1].unTokenName)
         ]),
-        new Constr2(0, [
+        new Constr(0, [
           params.versionRecordToken[0].unCurrencySymbol,
           fromText2(params.versionRecordToken[1].unTokenName)
         ]),
@@ -2647,10 +2671,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
 import { match as match10, P as P9 } from "ts-pattern";
-import { array as A2 } from "fp-ts";
+import { array as A3 } from "fp-ts";
 var teamVestingSchedule = [
   {
     vestedAtTime: 1669067100000n,
@@ -2837,7 +2865,7 @@ var govDistributionSchedule = {
   ]
 };
 function calculateTotalVestedTeam(currentTime) {
-  return A2.reduce(0n, (acc, schedule) => {
+  return A3.reduce(0n, (acc, schedule) => {
     if (currentTime >= schedule.vestedAtTime) {
       return acc + schedule.unlockAmt;
     } else {
@@ -2895,37 +2923,37 @@ function pollPassQuorum(initialIndyDist, pollStatus, currentTime, minQuorum, tre
 }
 
 // src/contracts/execute/types.ts
-import { Data as Data17 } from "@lucid-evolution/lucid";
+import { Data as Data18 } from "@lucid-evolution/lucid";
 import { option as O5, function as F6 } from "fp-ts";
-var ExecuteParamsSchema = Data17.Object({
+var ExecuteParamsSchema = Data18.Object({
   govNFT: AssetClassSchema,
   upgradeToken: AssetClassSchema,
   iAssetToken: AssetClassSchema,
   stabilityPoolToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  cdpValHash: Data17.Bytes(),
-  sPoolValHash: Data17.Bytes(),
-  versionRegistryValHash: Data17.Bytes(),
-  treasuryValHash: Data17.Bytes(),
+  cdpValHash: Data18.Bytes(),
+  sPoolValHash: Data18.Bytes(),
+  versionRegistryValHash: Data18.Bytes(),
+  treasuryValHash: Data18.Bytes(),
   indyAsset: AssetClassSchema
 });
 var ExecuteParams = ExecuteParamsSchema;
-var ExecuteDatumSchema = Data17.Object({
-  id: Data17.Integer(),
+var ExecuteDatumSchema = Data18.Object({
+  id: Data18.Integer(),
   content: ProposalContentSchema,
-  passedTime: Data17.Integer(),
-  votingEndTime: Data17.Integer(),
-  protocolVersion: Data17.Integer(),
+  passedTime: Data18.Integer(),
+  votingEndTime: Data18.Integer(),
+  protocolVersion: Data18.Integer(),
   /// Value proposed to be withdrawn from the treasury as part of the proposal.
-  treasuryWithdrawal: Data17.Nullable(TreasuryWithdrawalSchema)
+  treasuryWithdrawal: Data18.Nullable(TreasuryWithdrawalSchema)
 });
 var ExecuteDatum = ExecuteDatumSchema;
 function serialiseExecuteDatum(d) {
-  return Data17.to(d, ExecuteDatum);
+  return Data18.to(d, ExecuteDatum);
 }
 function parseExecuteDatum(d) {
   try {
-    return O5.some(Data17.from(d, ExecuteDatum));
+    return O5.some(Data18.from(d, ExecuteDatum));
   } catch (_) {
     return O5.none;
   }
@@ -2939,16 +2967,16 @@ function parseExecuteDatumOrThrow(d) {
   );
 }
 function castExecuteParams(params) {
-  return Data17.castTo(params, ExecuteParams);
+  return Data18.castTo(params, ExecuteParams);
 }
 
 // src/contracts/gov/helpers.ts
 import { pipe } from "fp-ts/lib/function";
 import {
-  array as A3,
+  array as A4,
   option as O6,
   string as S,
-  ord as Ord,
+  ord as Ord2,
   function as F7
 } from "fp-ts";
 import {
@@ -2959,7 +2987,7 @@ function proposalDeposit(baseDeposit, activeProposals) {
   return baseDeposit * 2n ** activeProposals;
 }
 function createValueFromWithdrawal(w) {
-  return A3.reduce(
+  return A4.reduce(
     {},
     (acc, [cs, tk, amt]) => addAssets4(acc, mkAssetsOf({ currencySymbol: cs, tokenName: tk }, amt))
   )(w.value);
@@ -2978,20 +3006,20 @@ async function findRelativeIAssetForInsertion(newIAssetTokenName, allIAssetOrefs
   return pipe(
     // Sort the asset names
     iassetUtxos,
-    A3.sort(
-      Ord.contramap((x) => toText2(x.datum.assetName))(
+    A4.sort(
+      Ord2.contramap((x) => toText2(x.datum.assetName))(
         S.Ord
       )
     ),
     // split head and tail
-    A3.foldLeft(
+    A4.foldLeft(
       () => O6.none,
       (head, rest) => O6.some([head, rest])
     ),
     // find the preceding iasset for the new token name
     O6.flatMap(
       ([firstIAsset, rest]) => O6.some(
-        A3.reduce(
+        A4.reduce(
           firstIAsset,
           (acc, iasset) => toText2(iasset.datum.assetName) < newIAssetTokenName ? iasset : acc
         )(rest)
@@ -3131,7 +3159,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
   }).otherwise(() => {
   });
   return [
-    tx.mintAssets(pollNftValue, Data18.void()).readFrom([govRefScriptUtxo, pollAuthTokenPolicyRefScriptUtxo]).collectFrom(
+    tx.mintAssets(pollNftValue, Data19.void()).readFrom([govRefScriptUtxo, pollAuthTokenPolicyRefScriptUtxo]).collectFrom(
       [govUtxo],
       serialiseGovRedeemer({
         CreatePoll: {
@@ -3229,7 +3257,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), Data18.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
+  ).mintAssets(mkAssetsOf(pollNft, shardsCount), Data19.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({ CreateShards: { currentTime } })
   ).pay.ToContract(
@@ -3399,8 +3427,8 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
   const shardUtxos = await lucid.utxosByOutRef(shardsOutRefs);
   const aggregatedStatus = F8.pipe(
     shardUtxos,
-    A4.map((utxo) => parsePollShardOrThrow(getInlineDatumOrThrow(utxo))),
-    A4.reduce(
+    A5.map((utxo) => parsePollShardOrThrow(getInlineDatumOrThrow(utxo))),
+    A5.reduce(
       pollManagerDatum.status,
       (acc, shard) => ({
         yesVotes: acc.yesVotes + shard.status.yesVotes,
@@ -3408,7 +3436,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
       })
     )
   );
-  const shardsAggregatedAda = A4.reduce(
+  const shardsAggregatedAda = A5.reduce(
     {},
     (acc, utxo) => addAssets5(acc, mkLovelacesOf(lovelacesAmt(utxo.assets)))
   )(shardUtxos);
@@ -3419,7 +3447,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     pollShardRefScriptUtxo,
     pollManagerRefScriptUtxo,
     pollAuthTokenPolicyRefScriptUtxo
-  ]).mintAssets(mkAssetsOf(pollNft, -BigInt(shardsOutRefs.length)), Data18.void()).collectFrom(
+  ]).mintAssets(mkAssetsOf(pollNft, -BigInt(shardsOutRefs.length)), Data19.void()).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({
       MergeShardsManager: { currentTime }
@@ -3529,7 +3557,7 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
   ).collectFrom(
     [govUtxo],
     serialiseGovRedeemer({ WitnessEndPoll: { currentTime } })
-  ).mintAssets(mkAssetsOf(pollNft, -1n), Data18.void()).pay.ToContract(
+  ).mintAssets(mkAssetsOf(pollNft, -1n), Data19.void()).pay.ToContract(
     govUtxo.address,
     {
       kind: "inline",
@@ -3555,11 +3583,11 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
         })
       },
       upgradeTokenVal
-    ).mintAssets(upgradeTokenVal, Data18.void());
+    ).mintAssets(upgradeTokenVal, Data19.void());
   } else {
     tx.pay.ToContract(
       createScriptAddress(network, sysParams.validatorHashes.treasuryHash),
-      { kind: "inline", value: Data18.void() },
+      { kind: "inline", value: Data19.void() },
       mkAssetsOf(
         indyAsset,
         assetClassValueOf(pollManagerUtxo.assets, indyAsset)
@@ -3654,7 +3682,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
                 sysParams.treasuryParams.treasuryUtxosStakeCredential
               ) : void 0
             ),
-            { kind: "inline", value: Data18.void() },
+            { kind: "inline", value: Data19.void() },
             withdrawalChangeVal
           );
         }
@@ -3731,7 +3759,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       cdpRefScriptUtxo,
       iassetTokenPolicyRefScriptUtxo,
       stabilityPoolTokenPolicyRefScriptUtxo
-    ]).mintAssets(spAuthVal, Data18.void()).mintAssets(iassetAuthVal, Data18.void()).collectFrom([govUtxo], serialiseGovRedeemer("UpgradeGov")).pay.ToContract(
+    ]).mintAssets(spAuthVal, Data19.void()).mintAssets(iassetAuthVal, Data19.void()).collectFrom([govUtxo], serialiseGovRedeemer("UpgradeGov")).pay.ToContract(
       govUtxo.address,
       {
         kind: "inline",
@@ -3897,7 +3925,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       fromSystemParamsAsset(sysParams.executeParams.versionRecordToken),
       1n
     );
-    tx.readFrom([govRefScriptUtxo, versionRecordTokenPolicyRefScriptUtxo]).mintAssets(versionRecordNftVal, Data18.void()).pay.ToContract(
+    tx.readFrom([govRefScriptUtxo, versionRecordTokenPolicyRefScriptUtxo]).mintAssets(versionRecordNftVal, Data19.void()).pay.ToContract(
       createScriptAddress(
         network,
         sysParams.validatorHashes.versionRegistryHash
@@ -3925,56 +3953,56 @@ 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], Data18.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], Data19.void()).mintAssets(
     mkAssetsOf(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
-    Data18.void()
+    Data19.void()
   ).addSigner(ownAddr);
   return tx;
 }
 
 // src/contracts/stability-pool/transactions.ts
 import {
-  Constr as Constr3,
+  Constr as Constr2,
   fromText as fromText5,
   validatorToScriptHash as validatorToScriptHash2,
-  Data as Data20,
+  Data as Data21,
   credentialToAddress as credentialToAddress3,
   fromHex as fromHex2,
   toHex
 } from "@lucid-evolution/lucid";
 
 // src/contracts/stability-pool/types.ts
-import { Data as Data19 } from "@lucid-evolution/lucid";
-var ActionReturnDatumSchema = Data19.Enum([
-  Data19.Object({
-    IndigoStabilityPoolAccountAdjustment: Data19.Object({
+import { Data as Data20 } from "@lucid-evolution/lucid";
+var ActionReturnDatumSchema = Data20.Enum([
+  Data20.Object({
+    IndigoStabilityPoolAccountAdjustment: Data20.Object({
       spent_account: OutputReferenceSchema
     })
   }),
-  Data19.Object({
-    IndigoStabilityPoolAccountClosure: Data19.Object({
+  Data20.Object({
+    IndigoStabilityPoolAccountClosure: Data20.Object({
       closed_account: OutputReferenceSchema
     })
   })
 ]);
 var ActionReturnDatum = ActionReturnDatumSchema;
-var StabilityPoolParamsSchema = Data19.Object({
-  assetSymbol: Data19.Bytes(),
+var StabilityPoolParamsSchema = Data20.Object({
+  assetSymbol: Data20.Bytes(),
   stabilityPoolToken: AssetClassSchema,
   snapshotEpochToScaleToSumToken: AssetClassSchema,
   accountToken: AssetClassSchema,
   cdpToken: AssetClassSchema,
   iAssetAuthToken: AssetClassSchema,
   versionRecordToken: AssetClassSchema,
-  collectorValHash: Data19.Bytes(),
+  collectorValHash: Data20.Bytes(),
   govNFT: AssetClassSchema,
-  accountCreateFeeLovelaces: Data19.Integer(),
-  accountAdjustmentFeeLovelaces: Data19.Integer(),
-  requestCollateralLovelaces: Data19.Integer()
+  accountCreateFeeLovelaces: Data20.Integer(),
+  accountAdjustmentFeeLovelaces: Data20.Integer(),
+  requestCollateralLovelaces: Data20.Integer()
 });
 var StabilityPoolParams = StabilityPoolParamsSchema;
 function castStabilityPoolParams(params) {
-  return Data19.castTo(params, StabilityPoolParams);
+  return Data20.castTo(params, StabilityPoolParams);
 }
 
 // src/contracts/stability-pool/scripts.ts
@@ -4217,7 +4245,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       {
         [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + fromText5(params.stabilityPoolParams.accountToken[1].unTokenName)]: 1n
       },
-      Data20.to(new Constr3(0, []))
+      Data21.to(new Constr2(0, []))
     );
     tx.pay.ToContract(
       stabilityPoolUtxo.address,
@@ -4378,7 +4406,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         outputAddress,
         {
           kind: "inline",
-          value: Data20.to(
+          value: Data21.to(
             {
               IndigoStabilityPoolAccountAdjustment: {
                 spent_account: {
@@ -4452,7 +4480,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       {
         [params.stabilityPoolParams.accountToken[0].unCurrencySymbol + fromText5(params.stabilityPoolParams.accountToken[1].unTokenName)]: -1n
       },
-      Data20.to(new Constr3(0, []))
+      Data21.to(new Constr2(0, []))
     );
     const assetOutputAmountForSP = stabilityPoolUtxo.assets[params.stabilityPoolParams.assetSymbol.unCurrencySymbol + fromText5(asset)] - fromSPInteger(withdrawnAmt) - withdrawalFeeAmount;
     tx.pay.ToContract(
@@ -4479,7 +4507,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
         outputAddress,
         {
           kind: "inline",
-          value: Data20.to(
+          value: Data21.to(
             {
               IndigoStabilityPoolAccountClosure: {
                 closed_account: {
@@ -4503,8 +4531,9 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
 
 // src/contracts/staking/transactions.ts
 import {
-  Constr as Constr4,
-  Data as Data21,
+  addAssets as addAssets6,
+  Constr as Constr3,
+  Data as Data22,
   fromHex as fromHex3,
   fromText as fromText6,
   toHex as toHex2
@@ -4541,7 +4570,7 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
   };
   const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + fromText6(params.stakingParams.stakingToken[1].unTokenName);
   const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + fromText6(params.stakingParams.indyToken[1].unTokenName);
-  return lucid.newTx().collectFrom([stakingManagerOut.utxo], Data21.to(new Constr4(0, [pkh.hash]))).readFrom([stakingRefScriptUtxo]).pay.ToContract(
+  return lucid.newTx().collectFrom([stakingManagerOut.utxo], Data22.to(new Constr3(0, [pkh.hash]))).readFrom([stakingRefScriptUtxo]).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
       kind: "inline",
@@ -4552,7 +4581,7 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     {
       [stakingToken]: 1n
     },
-    Data21.void()
+    Data22.void()
   ).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
@@ -4584,12 +4613,20 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
   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], Data21.to(new Constr4(3, [amount]))).collectFrom([stakingManagerOut.utxo], Data21.to(new Constr4(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",
@@ -4644,7 +4681,7 @@ async function closeStakingPosition(stakingPositionRef, params, lucid, stakingMa
   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], Data21.to(new Constr4(4, []))).collectFrom([stakingManagerOut.utxo], Data21.to(new Constr4(1, []))).pay.ToContract(
+  return lucid.newTx().validFrom(Date.now()).readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo]).collectFrom([stakingPositionOut.utxo], Data22.to(new Constr3(4, []))).collectFrom([stakingManagerOut.utxo], Data22.to(new Constr3(1, []))).pay.ToContract(
     stakingManagerOut.utxo.address,
     {
       kind: "inline",
@@ -4661,9 +4698,63 @@ async function closeStakingPosition(stakingPositionRef, params, lucid, stakingMa
     {
       [stakingToken]: -1n
     },
-    Data21.void()
+    Data22.void()
   ).addSignerKey(toHex2(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 === Data22.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 }
+      })
+    },
+    addAssets6(stakingManagerUtxo.assets, mkLovelacesOf(adaRewardCollected))
+  );
+  for (const collectorUtxo of collectorUtxos) {
+    tx.pay.ToContract(
+      collectorUtxo.address,
+      { kind: "inline", value: Data22.void() },
+      mkLovelacesOf(MIN_UTXO_AMOUNT)
+    );
+  }
+  return tx;
+}
 
 // src/contracts/interest-oracle/transactions.ts
 import {
@@ -4674,9 +4765,9 @@ import {
 
 // src/contracts/one-shot/transactions.ts
 import {
-  addAssets as addAssets6,
-  Constr as Constr5,
-  Data as Data23,
+  addAssets as addAssets7,
+  Constr as Constr4,
+  Data as Data24,
   mintingPolicyToId,
   toUnit as toUnit2
 } from "@lucid-evolution/lucid";
@@ -4687,23 +4778,23 @@ import {
 } from "@lucid-evolution/lucid";
 
 // src/contracts/one-shot/types.ts
-import { Data as Data22 } from "@lucid-evolution/lucid";
-var OneShotParamsSchema = Data22.Object({
-  referenceOutRef: Data22.Object({
-    txHash: Data22.Bytes(),
-    outputIdx: Data22.Integer()
+import { Data as Data23 } from "@lucid-evolution/lucid";
+var OneShotParamsSchema = Data23.Object({
+  referenceOutRef: Data23.Object({
+    txHash: Data23.Bytes(),
+    outputIdx: Data23.Integer()
   }),
-  mintAmounts: Data22.Array(
-    Data22.Object({
+  mintAmounts: Data23.Array(
+    Data23.Object({
       /// Use hex encoded string
-      tokenName: Data22.Bytes(),
-      amount: Data22.Integer()
+      tokenName: Data23.Bytes(),
+      amount: Data23.Integer()
     })
   )
 });
 var OneShotParams = OneShotParamsSchema;
 function castOneShotParams(params) {
-  return Data22.castTo(params, OneShotParams);
+  return Data23.castTo(params, OneShotParams);
 }
 
 // src/contracts/one-shot/scripts.ts
@@ -4740,11 +4831,11 @@ async function oneShotMintTx(lucid, params) {
     lucid.newTx().collectFrom([refUtxo]).mintAssets(
       reduce(
         {},
-        (acc, entry) => addAssets6(acc, {
+        (acc, entry) => addAssets7(acc, {
           [toUnit2(policyId, entry.tokenName)]: entry.amount
         })
       )(params.mintAmounts),
-      Data23.to(new Constr5(0, []))
+      Data24.to(new Constr4(0, []))
     ).attach.MintingPolicy(oneShotPolicy),
     policyId
   ];
@@ -4878,13 +4969,13 @@ async function feedInterestOracle(params, newInterestRate, lucid, assetClass, ut
 }
 
 // src/contracts/version-registry/types.ts
-import { Data as Data24 } from "@lucid-evolution/lucid";
-var VersionRecordTokenParamsSchema = Data24.Object({
+import { Data as Data25 } from "@lucid-evolution/lucid";
+var VersionRecordTokenParamsSchema = Data25.Object({
   upgradeToken: AssetClassSchema
 });
 var VersionRecordTokenParams = VersionRecordTokenParamsSchema;
 function castVersionRecordTokenParams(params) {
-  return Data24.castTo(params, VersionRecordTokenParams);
+  return Data25.castTo(params, VersionRecordTokenParams);
 }
 
 // src/contracts/version-registry/scripts.ts
@@ -4925,7 +5016,7 @@ var mkVersionRegistryValidator = () => {
 // src/contracts/collector/scripts.ts
 import {
   applyParamsToScript as applyParamsToScript9,
-  Constr as Constr6,
+  Constr as Constr5,
   fromText as fromText8
 } from "@lucid-evolution/lucid";
 
@@ -4941,16 +5032,16 @@ var mkCollectorValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
     script: applyParamsToScript9(_collectorValidator.cborHex, [
-      new Constr6(0, [
-        new Constr6(0, [
+      new Constr5(0, [
+        new Constr5(0, [
           params.stakingManagerNFT[0].unCurrencySymbol,
           fromText8(params.stakingManagerNFT[1].unTokenName)
         ]),
-        new Constr6(0, [
+        new Constr5(0, [
           params.stakingToken[0].unCurrencySymbol,
           fromText8(params.stakingToken[1].unTokenName)
         ]),
-        new Constr6(0, [
+        new Constr5(0, [
           params.versionRecordToken[0].unCurrencySymbol,
           fromText8(params.versionRecordToken[1].unTokenName)
         ])
@@ -4962,7 +5053,7 @@ var mkCollectorValidatorFromSP = (params) => {
 // src/contracts/treasury/scripts.ts
 import {
   applyParamsToScript as applyParamsToScript10,
-  Constr as Constr7,
+  Constr as Constr6,
   fromText as fromText9
 } from "@lucid-evolution/lucid";
 
@@ -4978,22 +5069,22 @@ var mkTreasuryValidatorFromSP = (params) => {
   return {
     type: "PlutusV2",
     script: applyParamsToScript10(_treasuryValidator.cborHex, [
-      new Constr7(0, [
-        new Constr7(0, [
+      new Constr6(0, [
+        new Constr6(0, [
           params.upgradeToken[0].unCurrencySymbol,
           fromText9(params.upgradeToken[1].unTokenName)
         ]),
-        new Constr7(0, [
+        new Constr6(0, [
           params.versionRecordToken[0].unCurrencySymbol,
           fromText9(params.versionRecordToken[1].unTokenName)
         ]),
-        params.treasuryUtxosStakeCredential ? new Constr7(0, [
-          new Constr7(0, [
-            new Constr7(1, [
+        params.treasuryUtxosStakeCredential ? new Constr6(0, [
+          new Constr6(0, [
+            new Constr6(1, [
               params.treasuryUtxosStakeCredential.contents.contents
             ])
           ])
-        ]) : new Constr7(1, [])
+        ]) : new Constr6(1, [])
       ])
     ])
   };
@@ -5045,66 +5136,280 @@ var mkExecuteValidatorFromSP = (params) => {
   };
 };
 
+// src/contracts/lrp/helpers.ts
+import { addAssets as addAssets8 } from "@lucid-evolution/lucid";
+
 // src/contracts/lrp/types.ts
-import { Data as Data25 } from "@lucid-evolution/lucid";
-var LRPParamsSchema = Data25.Object({
+import { Data as Data26 } from "@lucid-evolution/lucid";
+import { option as O8, function as F9 } from "fp-ts";
+var LRPParamsSchema = Data26.Object({
   versionRecordToken: AssetClassSchema,
   iassetNft: AssetClassSchema,
-  iassetPolicyId: Data25.Bytes(),
-  minRedemptionLovelacesAmt: Data25.Integer()
+  iassetPolicyId: Data26.Bytes(),
+  minRedemptionLovelacesAmt: Data26.Integer()
 });
 var LRPParams = LRPParamsSchema;
-var LRPDatumSchema = Data25.Object({
-  owner: Data25.Bytes(),
-  iasset: Data25.Bytes(),
+var LRPDatumSchema = Data26.Object({
+  owner: Data26.Bytes(),
+  iasset: Data26.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: Data25.Integer()
+  lovelacesToSpend: Data26.Integer()
 });
 var LRPDatum = LRPDatumSchema;
-var LRPRedeemerSchema = Data25.Enum([
-  Data25.Object({ Redeem: Data25.Object({ continuingOutputIdx: Data25.Integer() }) }),
-  Data25.Object({
-    RedeemAuxiliary: Data25.Object({
-      continuingOutputIdx: Data25.Integer(),
+var LRPRedeemerSchema = Data26.Enum([
+  Data26.Object({ Redeem: Data26.Object({ continuingOutputIdx: Data26.Integer() }) }),
+  Data26.Object({
+    RedeemAuxiliary: Data26.Object({
+      continuingOutputIdx: Data26.Integer(),
       mainRedeemOutRef: OutputReferenceSchema,
-      asset: Data25.Bytes(),
+      asset: Data26.Bytes(),
       assetPrice: OnChainDecimalSchema,
       redemptionReimbursementPercentage: OnChainDecimalSchema
     })
   }),
-  Data25.Literal("Cancel"),
-  Data25.Literal("UpgradeVersion")
+  Data26.Literal("Cancel"),
+  Data26.Literal("UpgradeVersion")
 ]);
 var LRPRedeemer = LRPRedeemerSchema;
 function parseLrpDatum(datum) {
-  return Data25.from(datum, LRPDatum);
+  try {
+    return O8.some(Data26.from(datum, LRPDatum));
+  } catch (_) {
+    return O8.none;
+  }
+}
+function parseLrpDatumOrThrow(datum) {
+  return F9.pipe(
+    parseLrpDatum(datum),
+    O8.match(() => {
+      throw new Error("Expected an LRP datum.");
+    }, F9.identity)
+  );
 }
 function serialiseLrpDatum(datum) {
-  return Data25.to(datum, LRPDatum);
+  return Data26.to(datum, LRPDatum);
 }
 function serialiseLrpRedeemer(redeemer) {
-  return Data25.to(redeemer, LRPRedeemer);
+  return Data26.to(redeemer, LRPRedeemer);
 }
 function castLrpParams(params) {
-  return Data25.castTo(params, LRPParams);
+  return Data26.castTo(params, LRPParams);
+}
+
+// src/contracts/lrp/helpers.ts
+import { array as A7, function as F10, ord as Ord4, option as O9 } from "fp-ts";
+
+// src/utils/array-utils.ts
+import { array as A6 } from "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 [...A6.takeLeft(i)(arr), item, ...A6.takeRight(arr.length - i)(arr)];
+    }
+  }
+  return [...arr, item];
+}
+
+// src/contracts/lrp/helpers.ts
+import { match as match12, P as P11 } from "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, _], __] = match12(redemptions).with(
+    [P11._, ...P11.array()],
+    ([[firstLrp, _2], ...rest]) => [
+      [firstLrp, _2],
+      rest
+    ]
+  ).otherwise(() => {
+    throw new Error("Expects at least 1 UTXO to redeem.");
+  });
+  const mainLrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(mainLrpUtxo));
+  return F10.pipe(
+    redemptions,
+    A7.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 = addAssets8(
+          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 F10.pipe(
+    allLrps,
+    A7.filterMap(([utxo, datum]) => {
+      if (datum.iasset !== iasset || datum.maxPrice.getOnChainInt < iassetPrice.getOnChainInt) {
+        return O9.none;
+      }
+      const lovelacesToSpend = lrpRedeemableLovelacesInclReimb(
+        [utxo, datum],
+        lrpParams
+      );
+      if (lovelacesToSpend === 0n) {
+        return O9.none;
+      }
+      return O9.some(lovelacesToSpend);
+    }),
+    // From largest to smallest
+    A7.sort(Ord4.reverse(BigIntOrd)),
+    // We can fit only this number of redemptions with CDP open into a single Tx.
+    A7.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(
+    F10.pipe(
+      allLrps,
+      A7.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,
+      Ord4.contramap(
+        ([_, dat]) => dat.lovelacesToSpend
+        // From highest to lowest
+      )(Ord4.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
 import {
-  addAssets as addAssets7,
+  addAssets as addAssets9,
   unixTimeToSlot as unixTimeToSlot2,
   slotToUnixTime as slotToUnixTime5
 } from "@lucid-evolution/lucid";
-import { match as match12, P as P11 } from "ts-pattern";
 import { unzip, zip } from "fp-ts/lib/Array";
-import { reduceWithIndex } from "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,
@@ -5113,38 +5418,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)
@@ -5154,69 +5468,14 @@ async function redeemLrp(redemptionLrpsData, lrpRefScriptOutRef, priceOracleOutR
     getInlineDatumOrThrow(priceOracleUtxo)
   );
   const redemptionLrps = await lucid.utxosByOutRef(lrpsToRedeemOutRefs).then((val) => zip(val, lrpRedemptionIAssetAmt));
-  const [[mainLrpUtxo, _], __] = match12(redemptionLrps).with(
-    [P11._, ...P11.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 = 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
-          })
-        },
-        addAssets7(
-          lrpUtxo.assets,
-          mkLovelacesOf(-lovelacesForRedemption + reimburstmentLovelaces),
-          mkAssetsOf(
-            {
-              currencySymbol: lrpParams.iassetPolicyId,
-              tokenName: mainLrpDatum.iasset
-            },
-            redeemIAssetAmt
-          )
-        )
-      );
-    }
-  )(redemptionLrps);
+    0n
+  );
   return lucid.newTx().validTo(
     slotToUnixTime5(
       network,
@@ -5224,18 +5483,20 @@ async function redeemLrp(redemptionLrpsData, lrpRefScriptOutRef, priceOracleOutR
     )
   ).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);
@@ -5258,15 +5519,15 @@ async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, lrpRefScriptOutRe
         lovelacesToSpend: lrpDatum.lovelacesToSpend + lovelacesAdjustAmt
       })
     },
-    addAssets7(
+    addAssets9(
       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
@@ -5318,6 +5579,366 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
   await lucid.awaitTx(txHash);
   return { txHash, outputIndex: 0 };
 }
+
+// src/contracts/leverage/transactions.ts
+import {
+  addAssets as addAssets10,
+  slotToUnixTime as slotToUnixTime6,
+  Data as Data27
+} from "@lucid-evolution/lucid";
+
+// src/contracts/leverage/helpers.ts
+import { array as A8, function as F11 } from "fp-ts";
+import { Decimal as Decimal2 } from "decimal.js";
+var MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+function approximateLeverageRedemptions(baseCollateral, targetLeverage, redemptionReimbursementPercentage, debtMintingFeePercentage) {
+  const debtMintingFeeRatioDecimal = Decimal2(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = Decimal2(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const bExFees = Decimal2(baseCollateral).mul(targetLeverage).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal2(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = {
+    getOnChainInt: fromDecimal(
+      Decimal2(Decimal2(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 = Decimal2(iassetPrice.getOnChainInt).div(OCD_DECIMAL_UNIT);
+  const redemptionDetails = F11.pipe(
+    redemptionLrps,
+    A8.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(
+          Decimal2(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 = F11.pipe(
+    redemptionDetails.redemptions,
+    A8.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 = Decimal2(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = Decimal2(
+    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 = Decimal2(baseCollateral).mul(leverage).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal2(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableAdaForRedemptionInclReimb,
+    fromDecimal(b)
+  );
+  const cappedBExFees = Decimal2(cappedB).mul(Decimal2(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = Decimal2(
+    Decimal2(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 = Decimal2(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = Decimal2(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const collateralRatio = Decimal2(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 = Decimal2(Decimal2(1).minus(totalFeeRatio)).div(collateralRatio.minus(1).add(totalFeeRatio)).add(1);
+  const bExFees = theoreticalMaxLeverage.mul(baseCollateral).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal2(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableAdaForRedemptionInclReimb,
+    fromDecimal(b)
+  );
+  const cappedBExFees = Decimal2(cappedB).mul(Decimal2(1).minus(totalFeeRatio)).floor();
+  return Decimal2(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(slotToUnixTime6(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, Data27.void()).mintAssets(iassetTokensVal, Data27.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
+          }
+        }
+      })
+    },
+    addAssets10(cdpNftVal, mkLovelacesOf(collateralAmt))
+  ).pay.ToContract(
+    cdpCreatorUtxo.address,
+    { kind: "inline", value: Data27.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;
+}
 export {
   AccountContentSchema,
   ActionReturnDatum,
@@ -5345,6 +5966,8 @@ export {
   LRPDatumSchema,
   LRPParamsSchema,
   LRPRedeemerSchema,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN,
+  MIN_LRP_COLLATERAL_AMT,
   ONE_DAY,
   ONE_HOUR,
   ONE_SECOND,
@@ -5375,12 +5998,17 @@ export {
   adjustSpAccount,
   adjustStakingPosition,
   adjustmentHelper,
+  approximateLeverageRedemptions,
   assetClassToUnit,
   assetClassValueOf,
   balance,
+  buildRedemptionsTx,
   burnCdp,
+  calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalAdaForRedemption,
   cancelLrp,
   castCDPCreatorParams,
   castCdpParams,
@@ -5405,6 +6033,7 @@ export {
   createShardsChunks,
   createSpAccount,
   depositCdp,
+  distributeAda,
   endProposal,
   executeProposal,
   feedInterestOracle,
@@ -5420,12 +6049,15 @@ export {
   getSumFromEpochToScaleToSum,
   initEpochToScaleToSumMap,
   initSpSnapshot,
+  insertSorted,
   isAssetsZero,
+  leverageCdpWithLrp,
   liquidateCdp,
   liquidationHelper,
   loadSystemParamsFromFile,
   loadSystemParamsFromUrl,
   lovelacesAmt,
+  lrpRedeemableLovelacesInclReimb,
   matchSingle,
   mergeCdps,
   mergeShards,
@@ -5465,6 +6097,7 @@ export {
   parseIAssetDatumOrThrow,
   parseInterestOracleDatum,
   parseLrpDatum,
+  parseLrpDatumOrThrow,
   parsePriceOracleDatum,
   parseSnapshotEpochToScaleToSumDatum,
   parseStabilityPoolDatum,
@@ -5472,6 +6105,7 @@ export {
   parseStakingPosition,
   parseStakingPositionOrThrow,
   processSpRequest,
+  randomLrpsSubsetSatisfyingTargetLovelaces,
   redeemCdp,
   redeemLrp,
   runCreateScriptRefTx,
@@ -5498,11 +6132,13 @@ export {
   serialiseStakingDatum,
   serialiseStakingRedeemer,
   setSumInEpochToScaleToSum,
+  shuffle,
   spAdd,
   spDiv,
   spMul,
   spSub,
   startInterestOracle,
+  summarizeActualLeverageRedemptions,
   toSystemParamsAsset,
   treasuryFeeTx,
   updatePoolSnapshotWithdrawalFee,