@indigo-labs/indigo-sdk 0.3.9 → 0.3.10

package/dist/index.mjs

@@ -387,7 +387,6 @@ function loadSystemParamsFromFile(file) {
 function loadSystemParamsFromUrl(url) {
   return fetch(url).then((res) => res.json()).then((data) => data);
 }
-var getRandomElement = (arr) => arr.length ? arr[Math.floor(Math.random() * arr.length)] : void 0;
 
 // src/utils/time-helpers.ts
 var ONE_SECOND = 1e3;
@@ -467,6 +466,11 @@ function calculateFeeFromRatio(feeRatio, amount) {
 
 // src/contracts/cdp/helpers.ts
 import { assetClassValueOf } from "@3rd-eye-labs/cardano-offchain-common";
+function iassetValueOfCollateral(collateralAmt, oraclePrice) {
+  return rationalFloor(
+    rationalDiv(rationalFromInt(collateralAmt), oraclePrice)
+  );
+}
 function cdpCollateralRatioPercentage(currentSlot, iassetPrice, cdpUtxo, cdpContent, interestOracleDatum, network) {
   const currentTime = BigInt(slotToUnixTime2(network, currentSlot));
   return match4(cdpContent.cdpFees).with({ ActiveCDPInterestTracking: P4.select() }, (interest) => {
@@ -3653,6 +3657,7 @@ function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythS
   }).with(
     { DeferredValidation: { feedValHash: P11.select() } },
     async (feedValHash) => {
+      if (priceOracleOref) throw new Error("Cannot pass price oracle oref");
       if (!pythMessage) throw new Error("Missing Pyth message");
       if (!pythStateOref) throw new Error("Missing pyth state out ref");
       const pythStateUtxo = matchSingle(
@@ -5120,184 +5125,21 @@ var mkPollShardValidatorFromSP = (params) => {
   };
 };
 
-// src/contracts/poll/types-poll-new.ts
-import { TSchema as TSchema15, Data as Data25 } from "@evolution-sdk/evolution";
-import {
-  AddressSchema as AddressSchema3,
-  OutputReferenceSchema as OutputReferenceSchema5
-} from "@3rd-eye-labs/cardano-offchain-common";
-import { option as O10, function as F12 } from "fp-ts";
-import { match as match14, P as P14 } from "ts-pattern";
-var PollStatusSchema = TSchema15.Struct({
-  yesVotes: TSchema15.Integer,
-  noVotes: TSchema15.Integer
-});
-var PollManagerContentSchema = TSchema15.Struct({
-  pollId: TSchema15.Integer,
-  pollOwner: TSchema15.ByteArray,
-  content: ProposalContentSchema,
-  treasuryWithdrawal: TSchema15.NullOr(TreasuryWithdrawalSchema),
-  status: PollStatusSchema,
-  votingEndTime: TSchema15.Integer,
-  createdShardsCount: TSchema15.Integer,
-  talliedShardsCount: TSchema15.Integer,
-  totalShardsCount: TSchema15.Integer,
-  proposingEndTime: TSchema15.Integer,
-  expirationTime: TSchema15.Integer,
-  protocolVersion: TSchema15.Integer,
-  minimumQuorum: TSchema15.Integer
-});
-var PollShardContentSchema = TSchema15.Struct({
-  pollId: TSchema15.Integer,
-  status: PollStatusSchema,
-  votingEndTime: TSchema15.Integer,
-  managerAddress: AddressSchema3
-});
-var PollDatumSchema = TSchema15.Union(
-  TSchema15.Struct(
-    {
-      PollManager: PollManagerContentSchema
-    },
-    { flatInUnion: true }
-  ),
-  TSchema15.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
-);
-var VoteOptionSchema = TSchema15.Union(
-  TSchema15.Literal("Yes", { flatInUnion: true }),
-  TSchema15.Literal("No", { flatInUnion: true })
-);
-var PollShardRedeemerSchema = TSchema15.Union(
-  TSchema15.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
-  TSchema15.Struct(
-    {
-      MergeShards: TSchema15.Struct(
-        {
-          currentTime: TSchema15.Integer,
-          pollManagerRef: OutputReferenceSchema5
-        },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-var PollManagerRedeemerSchema = TSchema15.Union(
-  TSchema15.Struct(
-    {
-      EndPoll: TSchema15.Struct(
-        { currentTime: TSchema15.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  TSchema15.Struct(
-    {
-      CreateShards: TSchema15.Struct(
-        { currentTime: TSchema15.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  ),
-  TSchema15.Struct(
-    {
-      MergeShardsManager: TSchema15.Struct(
-        { currentTime: TSchema15.Integer },
-        { flatFields: true }
-      )
-    },
-    { flatInUnion: true }
-  )
-);
-function serialisePollManagerRedeemer(r) {
-  return Data25.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
-}
-function serialisePollShardRedeemer(r) {
-  return Data25.withSchema(PollShardRedeemerSchema).toCBORHex(r);
-}
-function parsePollManager(datum) {
-  try {
-    return match14(
-      Data25.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollManager: P14.select() }, (res) => O10.some(res)).otherwise(() => O10.none);
-  } catch (_) {
-    return O10.none;
-  }
-}
-function parsePollManagerOrThrow(datum) {
-  return F12.pipe(
-    parsePollManager(datum),
-    O10.match(() => {
-      throw new Error("Expected a poll manager datum.");
-    }, F12.identity)
-  );
-}
-function parsePollShard(datum) {
-  try {
-    return match14(
-      Data25.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
-        datum
-      )
-    ).with({ PollShard: P14.select() }, (res) => O10.some(res)).otherwise(() => O10.none);
-  } catch (_) {
-    return O10.none;
-  }
-}
-function parsePollShardOrThrow(datum) {
-  return F12.pipe(
-    parsePollShard(datum),
-    O10.match(() => {
-      throw new Error("Expected a poll shard datum.");
-    }, F12.identity)
-  );
-}
-function serialisePollDatum(d) {
-  return Data25.withSchema(PollDatumSchema).toCBORHex(d);
-}
-
-// src/contracts/poll/helpers.ts
-function q(pollStatus, e) {
-  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
-    return { getOnChainInt: 0n };
-  else {
-    const q2 = ocdDiv(
-      { getOnChainInt: pollStatus.yesVotes },
-      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
-    ).getOnChainInt - ocdDiv(
-      { getOnChainInt: pollStatus.noVotes },
-      {
-        getOnChainInt: BigInt(
-          Math.floor(
-            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
-          )
-        )
-      }
-    ).getOnChainInt;
-    return { getOnChainInt: BigInt(q2) };
-  }
-}
-function pollPassQuorum(pollStatus, electorate, minQuorum) {
-  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
-}
-
 // src/contracts/collector/transactions.ts
 import {
   addAssets as addAssets7,
-  Data as Data27
+  Data as Data26
 } from "@lucid-evolution/lucid";
 
 // src/contracts/collector/types-new.ts
-import { TSchema as TSchema16, Data as Data26 } from "@evolution-sdk/evolution";
-var CollectorRedeemerSchema = TSchema16.Union(
-  TSchema16.Literal("Collect", { flatInUnion: true }),
-  TSchema16.Literal("DistributeToStakers", { flatInUnion: true }),
-  TSchema16.Literal("UpgradeVersion", { flatInUnion: true })
+import { TSchema as TSchema15, Data as Data25 } from "@evolution-sdk/evolution";
+var CollectorRedeemerSchema = TSchema15.Union(
+  TSchema15.Literal("Collect", { flatInUnion: true }),
+  TSchema15.Literal("DistributeToStakers", { flatInUnion: true }),
+  TSchema15.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseCollectorRedeemer(r) {
-  return Data26.withSchema(
+  return Data25.withSchema(
     CollectorRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
@@ -5318,7 +5160,7 @@ async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
   );
   tx.collectFrom([collectorUtxo], serialiseCollectorRedeemer("Collect")).pay.ToContract(
     collectorUtxo.address,
-    { kind: "inline", value: Data27.void() },
+    { kind: "inline", value: Data26.void() },
     addAssets7(collectorUtxo.assets, mkLovelacesOf2(fee))
   ).readFrom([collectorRefScriptUtxo]);
   return collectorRefScriptUtxo;
@@ -5348,95 +5190,95 @@ import { array as A8, option as O12, function as F14 } from "fp-ts";
 import { match as match16, P as P16 } from "ts-pattern";
 
 // src/contracts/staking/types-new.ts
-import { TSchema as TSchema17, Data as Data28 } from "@evolution-sdk/evolution";
-import { option as O11, function as F13 } from "fp-ts";
-import { match as match15, P as P15 } from "ts-pattern";
-var StakingPosLockedAmtSchema = TSchema17.Array(
-  TSchema17.Tuple([
-    TSchema17.Integer,
-    TSchema17.Struct({
-      voteAmt: TSchema17.Integer,
-      votingEnd: TSchema17.Integer
+import { TSchema as TSchema16, Data as Data27 } from "@evolution-sdk/evolution";
+import { option as O10, function as F12 } from "fp-ts";
+import { match as match14, P as P14 } from "ts-pattern";
+var StakingPosLockedAmtSchema = TSchema16.Array(
+  TSchema16.Tuple([
+    TSchema16.Integer,
+    TSchema16.Struct({
+      voteAmt: TSchema16.Integer,
+      votingEnd: TSchema16.Integer
     })
   ])
 );
-var RewardSnapshotSchema = TSchema17.Struct({
-  snapshotAda: TSchema17.Integer
+var RewardSnapshotSchema = TSchema16.Struct({
+  snapshotAda: TSchema16.Integer
 });
-var StakingPositionSchema = TSchema17.Struct({
-  owner: TSchema17.ByteArray,
+var StakingPositionSchema = TSchema16.Struct({
+  owner: TSchema16.ByteArray,
   lockedAmount: StakingPosLockedAmtSchema,
   positionSnapshot: RewardSnapshotSchema
 });
-var StakingManagerSchema = TSchema17.Struct({
-  totalStake: TSchema17.Integer,
+var StakingManagerSchema = TSchema16.Struct({
+  totalStake: TSchema16.Integer,
   managerSnapshot: RewardSnapshotSchema
 });
-var StakingDatumSchema = TSchema17.Union(
+var StakingDatumSchema = TSchema16.Union(
   StakingManagerSchema,
   StakingPositionSchema
 );
-var StakingRedeemerSchema = TSchema17.Union(
-  TSchema17.Struct(
+var StakingRedeemerSchema = TSchema16.Union(
+  TSchema16.Struct(
     {
-      CreateStakingPosition: TSchema17.Struct(
-        { creatorPkh: TSchema17.ByteArray },
+      CreateStakingPosition: TSchema16.Struct(
+        { creatorPkh: TSchema16.ByteArray },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  TSchema17.Literal("UpdateTotalStake", { flatInUnion: true }),
-  TSchema17.Literal("Distribute", { flatInUnion: true }),
-  TSchema17.Struct(
+  TSchema16.Literal("UpdateTotalStake", { flatInUnion: true }),
+  TSchema16.Literal("Distribute", { flatInUnion: true }),
+  TSchema16.Struct(
     {
-      AdjustStakedAmount: TSchema17.Struct(
-        { adjustAmount: TSchema17.Integer },
+      AdjustStakedAmount: TSchema16.Struct(
+        { adjustAmount: TSchema16.Integer },
         { flatFields: true }
       )
     },
     { flatInUnion: true }
   ),
-  TSchema17.Literal("Unstake", { flatInUnion: true }),
-  TSchema17.Literal("Lock", { flatInUnion: true }),
-  TSchema17.Literal("UpgradeVersion", { flatInUnion: true })
+  TSchema16.Literal("Unstake", { flatInUnion: true }),
+  TSchema16.Literal("Lock", { flatInUnion: true }),
+  TSchema16.Literal("UpgradeVersion", { flatInUnion: true })
 );
 function serialiseStakingRedeemer(r) {
-  return Data28.withSchema(
+  return Data27.withSchema(
     StakingRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
 }
 function parseStakingPosition(datum) {
   try {
-    return match15(
-      Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+    return match14(
+      Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
         datum
       )
-    ).with({ owner: P15.any }, (res) => O11.some(res)).otherwise(() => O11.none);
+    ).with({ owner: P14.any }, (res) => O10.some(res)).otherwise(() => O10.none);
   } catch (_) {
-    return O11.none;
+    return O10.none;
   }
 }
 function parseStakingPositionOrThrow(datum) {
-  return F13.pipe(
+  return F12.pipe(
     parseStakingPosition(datum),
-    O11.match(() => {
+    O10.match(() => {
       throw new Error("Expected a StakingPosition datum.");
-    }, F13.identity)
+    }, F12.identity)
   );
 }
 function parseStakingManagerDatum(datum) {
-  return match15(
-    Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+  return match14(
+    Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
       datum
     )
-  ).with({ totalStake: P15.any }, (res) => res).otherwise(() => {
+  ).with({ totalStake: P14.any }, (res) => res).otherwise(() => {
     throw new Error("Expected a StakingPosition datum.");
   });
 }
 function serialiseStakingDatum(d) {
-  return Data28.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
+  return Data27.withSchema(StakingDatumSchema, DEFAULT_SCHEMA_OPTIONS).toCBORHex(
     d
   );
 }
@@ -5558,51 +5400,214 @@ function calculateAdaReward(currentSnapshotAda, oldSnapshotAda, existingIndyAmou
   return (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / rewardSnapshotPrecision;
 }
 
+// src/contracts/poll/helpers.ts
+function q(pollStatus, e) {
+  if (pollStatus.yesVotes + pollStatus.noVotes === 0n)
+    return { getOnChainInt: 0n };
+  else {
+    const q2 = ocdDiv(
+      { getOnChainInt: pollStatus.yesVotes },
+      { getOnChainInt: BigInt(Math.floor(Math.sqrt(Number(e)))) }
+    ).getOnChainInt - ocdDiv(
+      { getOnChainInt: pollStatus.noVotes },
+      {
+        getOnChainInt: BigInt(
+          Math.floor(
+            Math.sqrt(Number(pollStatus.yesVotes + pollStatus.noVotes))
+          )
+        )
+      }
+    ).getOnChainInt;
+    return { getOnChainInt: BigInt(q2) };
+  }
+}
+function pollPassQuorum(pollStatus, electorate, minQuorum) {
+  return pollStatus.yesVotes + pollStatus.noVotes >= minQuorum && q(pollStatus, electorate).getOnChainInt > 50000n;
+}
+
 // src/contracts/version-registry/types-new.ts
-import { TSchema as TSchema18, Data as Data29 } from "@evolution-sdk/evolution";
-var VersionRecordDatumSchema = TSchema18.Struct({
-  upgradeId: TSchema18.Integer,
+import { TSchema as TSchema17, Data as Data28 } from "@evolution-sdk/evolution";
+var VersionRecordDatumSchema = TSchema17.Struct({
+  upgradeId: TSchema17.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: TSchema18.Array(
-    TSchema18.Tuple([TSchema18.ByteArray, TSchema18.ByteArray])
+  upgradePaths: TSchema17.Array(
+    TSchema17.Tuple([TSchema17.ByteArray, TSchema17.ByteArray])
   )
 });
 function serialiseVersionRecordDatum(d) {
-  return Data29.withSchema(
+  return Data28.withSchema(
     VersionRecordDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
 }
 
-// src/contracts/gov/transactions.ts
+// src/contracts/poll/types-poll-new.ts
+import { TSchema as TSchema18, Data as Data29 } from "@evolution-sdk/evolution";
 import {
-  addressFromBech32,
-  addressToBech32
+  AddressSchema as AddressSchema3,
+  OutputReferenceSchema as OutputReferenceSchema5
 } from "@3rd-eye-labs/cardano-offchain-common";
-async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
-  const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
-  const ownAddr = await lucid.wallet().address();
-  const pkh = paymentCredentialOf2(ownAddr);
-  const govRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.governanceValidatorRef
+import { option as O11, function as F13 } from "fp-ts";
+import { match as match15, P as P15 } from "ts-pattern";
+var PollStatusSchema = TSchema18.Struct({
+  yesVotes: TSchema18.Integer,
+  noVotes: TSchema18.Integer
+});
+var PollManagerContentSchema = TSchema18.Struct({
+  pollId: TSchema18.Integer,
+  pollOwner: TSchema18.ByteArray,
+  content: ProposalContentSchema,
+  treasuryWithdrawal: TSchema18.NullOr(TreasuryWithdrawalSchema),
+  status: PollStatusSchema,
+  votingEndTime: TSchema18.Integer,
+  createdShardsCount: TSchema18.Integer,
+  talliedShardsCount: TSchema18.Integer,
+  totalShardsCount: TSchema18.Integer,
+  proposingEndTime: TSchema18.Integer,
+  expirationTime: TSchema18.Integer,
+  protocolVersion: TSchema18.Integer,
+  minimumQuorum: TSchema18.Integer
+});
+var PollShardContentSchema = TSchema18.Struct({
+  pollId: TSchema18.Integer,
+  status: PollStatusSchema,
+  votingEndTime: TSchema18.Integer,
+  managerAddress: AddressSchema3
+});
+var PollDatumSchema = TSchema18.Union(
+  TSchema18.Struct(
+    {
+      PollManager: PollManagerContentSchema
+    },
+    { flatInUnion: true }
+  ),
+  TSchema18.Struct({ PollShard: PollShardContentSchema }, { flatInUnion: true })
+);
+var VoteOptionSchema = TSchema18.Union(
+  TSchema18.Literal("Yes", { flatInUnion: true }),
+  TSchema18.Literal("No", { flatInUnion: true })
+);
+var PollShardRedeemerSchema = TSchema18.Union(
+  TSchema18.Struct({ Vote: VoteOptionSchema }, { flatInUnion: true }),
+  TSchema18.Struct(
+    {
+      MergeShards: TSchema18.Struct(
+        {
+          currentTime: TSchema18.Integer,
+          pollManagerRef: OutputReferenceSchema5
+        },
+        { flatFields: true }
       )
-    ]),
-    (_) => new Error("Expected a single Gov Ref Script UTXO")
-  );
-  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
-    await lucid.utxosByOutRef([
-      fromSystemParamsScriptRef(
-        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef
+    },
+    { flatInUnion: true }
+  )
+);
+var PollManagerRedeemerSchema = TSchema18.Union(
+  TSchema18.Struct(
+    {
+      EndPoll: TSchema18.Struct(
+        { currentTime: TSchema18.Integer },
+        { flatFields: true }
       )
-    ]),
-    (_) => new Error("Expected a single poll auth token policy ref Script UTXO")
+    },
+    { flatInUnion: true }
+  ),
+  TSchema18.Struct(
+    {
+      CreateShards: TSchema18.Struct(
+        { currentTime: TSchema18.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  ),
+  TSchema18.Struct(
+    {
+      MergeShardsManager: TSchema18.Struct(
+        { currentTime: TSchema18.Integer },
+        { flatFields: true }
+      )
+    },
+    { flatInUnion: true }
+  )
+);
+function serialisePollManagerRedeemer(r) {
+  return Data29.withSchema(PollManagerRedeemerSchema).toCBORHex(r);
+}
+function serialisePollShardRedeemer(r) {
+  return Data29.withSchema(PollShardRedeemerSchema).toCBORHex(r);
+}
+function parsePollManager(datum) {
+  try {
+    return match15(
+      Data29.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollManager: P15.select() }, (res) => O11.some(res)).otherwise(() => O11.none);
+  } catch (_) {
+    return O11.none;
+  }
+}
+function parsePollManagerOrThrow(datum) {
+  return F13.pipe(
+    parsePollManager(datum),
+    O11.match(() => {
+      throw new Error("Expected a poll manager datum.");
+    }, F13.identity)
   );
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error("Expected a single Gov UTXO")
+}
+function parsePollShard(datum) {
+  try {
+    return match15(
+      Data29.withSchema(PollDatumSchema, DEFAULT_SCHEMA_OPTIONS).fromCBORHex(
+        datum
+      )
+    ).with({ PollShard: P15.select() }, (res) => O11.some(res)).otherwise(() => O11.none);
+  } catch (_) {
+    return O11.none;
+  }
+}
+function parsePollShardOrThrow(datum) {
+  return F13.pipe(
+    parsePollShard(datum),
+    O11.match(() => {
+      throw new Error("Expected a poll shard datum.");
+    }, F13.identity)
+  );
+}
+function serialisePollDatum(d) {
+  return Data29.withSchema(PollDatumSchema).toCBORHex(d);
+}
+
+// src/contracts/gov/transactions.ts
+import {
+  addressFromBech32,
+  addressToBech32
+} from "@3rd-eye-labs/cardano-offchain-common";
+async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
+  const network = lucid.config().network;
+  const currentTime = BigInt(slotToUnixTime6(network, currentSlot));
+  const ownAddr = await lucid.wallet().address();
+  const pkh = paymentCredentialOf2(ownAddr);
+  const govRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.governanceValidatorRef
+      )
+    ]),
+    (_) => new Error("Expected a single Gov Ref Script UTXO")
+  );
+  const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.authTokenPolicies.pollManagerTokenRef
+      )
+    ]),
+    (_) => new Error("Expected a single poll auth token policy ref Script UTXO")
+  );
+  const govUtxo = matchSingle(
+    await lucid.utxosByOutRef([govOref]),
+    (_) => new Error("Expected a single Gov UTXO")
   );
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
   const votingEndTime = currentTime + govDatum.protocolParams.votingPeriod;
@@ -5694,9 +5699,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
           )
         )
       )
-    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(
-      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
-    ).addSigner(ownAddr),
+    ).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).addSigner(ownAddr),
     newPollId
   ];
 }
@@ -5738,7 +5741,7 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
   );
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   const tx = lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).mintAssets(mkAssetsOf6(pollNft, shardsCount), Data30.void()).readFrom([pollAuthTokenPolicyRefScriptUtxo, pollManagerRefScriptUtxo]).collectFrom(
     [pollManagerUtxo],
     serialisePollManagerRedeemer({ CreateShards: { currentTime } })
@@ -5918,7 +5921,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
   )(shardUtxos);
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   return lucid.newTx().validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
+    Number(currentTime + sysParams.pollManagerParams.pBiasTime) - ONE_SECOND
   ).readFrom([
     pollShardRefScriptUtxo,
     pollManagerRefScriptUtxo,
@@ -6705,9 +6708,7 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     );
   }).otherwise(() => {
   });
-  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(
-    Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
-  ).collectFrom([executeUtxo], Data30.void()).mintAssets(
+  tx.readFrom([upgradeTokenPolicyRefScriptUtxo, executeRefScriptUtxo]).validFrom(Number(currentTime) - ONE_SECOND).validTo(Number(currentTime + sysParams.govParams.gBiasTime) - ONE_SECOND).collectFrom([executeUtxo], Data30.void()).mintAssets(
     mkAssetsOf6(fromSystemParamsAsset(sysParams.govParams.upgradeToken), -1n),
     Data30.void()
   ).addSigner(ownAddr).setMinFee(922932n);
@@ -8291,7 +8292,8 @@ import {
   readonlyArray as RA3,
   array as A9,
   function as F16,
-  option as O14
+  option as O14,
+  ord as Ord4
 } from "fp-ts";
 import { match as match18, P as P18 } from "ts-pattern";
 import {
@@ -8302,7 +8304,7 @@ import {
   mkAssetsOf as mkAssetsOf9
 } from "@3rd-eye-labs/cardano-offchain-common";
 var MIN_ROB_COLLATERAL_AMT = 3000000n;
-function robAmountToSpend(utxo, datum, sysParams) {
+function robCollateralAmtToSpend(utxo, datum) {
   return match18(datum.orderType).returnType().with({ BuyIAssetOrder: P18.select() }, (content) => {
     if (isSameAssetClass3(adaAssetClass4, content.collateralAsset)) {
       return zeroNegatives(
@@ -8311,24 +8313,61 @@ function robAmountToSpend(utxo, datum, sysParams) {
     } else {
       return assetClassValueOf7(utxo.assets, content.collateralAsset);
     }
-  }).with({ SellIAssetOrder: P18.any }, (_) => {
+  }).otherwise(() => {
+    throw new Error("Collateral to spend is relevant only for Buy orders.");
+  });
+}
+function robIAssetAmtToSpend(utxo, datum, iassetCurrencySymbol) {
+  return match18(datum.orderType).returnType().with({ SellIAssetOrder: P18.any }, (_) => {
     return assetClassValueOf7(utxo.assets, {
-      currencySymbol: fromHex12(
-        sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol
-      ),
+      currencySymbol: fromHex12(iassetCurrencySymbol.unCurrencySymbol),
       tokenName: datum.iasset
     });
-  }).exhaustive();
+  }).otherwise(() => {
+    throw new Error("IAssets to spend is relevant only for Sell orders.");
+  });
 }
-function isFullyRedeemed(utxo, datum, sysParams) {
-  return robAmountToSpend(utxo, datum, sysParams) === 0n;
+function robAmtToSpend(utxo, datum, iassetCurrencySymbol) {
+  return match18(datum.orderType).with({ BuyIAssetOrder: P18.any }, () => robCollateralAmtToSpend(utxo, datum)).with(
+    { SellIAssetOrder: P18.any },
+    () => robIAssetAmtToSpend(utxo, datum, iassetCurrencySymbol)
+  ).exhaustive();
+}
+function robBuyOrderSummary(utxo, datum, oraclePrice) {
+  const redeemable = robCollateralAmtToSpend(utxo, datum);
+  const payoutAmt = iassetValueOfCollateral(redeemable, oraclePrice);
+  return {
+    redeemableCollateral: redeemable,
+    payoutIAsset: payoutAmt
+  };
+}
+function isBuyOrderFullyRedeemed(utxo, datum, oraclePrice) {
+  const summary = robBuyOrderSummary(utxo, datum, oraclePrice);
+  return summary.redeemableCollateral <= 0n || summary.payoutIAsset <= 0n;
+}
+function isFullyRedeemed(utxo, datum, iassetCurrencySymbol) {
+  return match18(datum.orderType).returnType().with(
+    { BuyIAssetOrder: P18.select() },
+    (content) => isBuyOrderFullyRedeemed(utxo, datum, content.maxPrice)
+  ).with({ SellIAssetOrder: P18.select() }, (content) => {
+    const iassetToSpend = robIAssetAmtToSpend(
+      utxo,
+      datum,
+      iassetCurrencySymbol
+    );
+    const payoutAmts = content.allowedCollateralAssets.map(
+      (c) => rationalFloor(rationalMul(rationalFromInt(iassetToSpend), c[1]))
+    );
+    return iassetToSpend <= 0n || // When for every allowed collateral asset the payout would be 0
+    payoutAmts.every((amt) => amt <= 0n);
+  }).exhaustive();
 }
 function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redemptionReimbursementRatio, sysParams, tx, txOutputsBeforeCount, collateralAssetRefInputIdx, iassetRefInputIdx, oracleIdx) {
   return F16.pipe(
     redemptions,
     A9.reduceWithIndex(
       tx,
-      (idx, acc, [robUtxo, spendAmt]) => {
+      (idx, acc, [robUtxo, payoutAmt]) => {
         const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
         if (toHex12(robDatum.iasset) !== toHex12(iasset)) {
           throw new Error("Only same iAsset");
@@ -8339,7 +8378,7 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
           if (!isSameAssetClass3(content.collateralAsset, collateralAsset)) {
             throw new Error("Only same collateral asset");
           }
-          const payoutIAssetAmt = spendAmt;
+          const payoutIAssetAmt = payoutAmt;
           const reimburstmentIAsset = calculateFeeFromRatio(
             redemptionReimbursementRatio,
             payoutIAssetAmt
@@ -8374,16 +8413,14 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
               throw new Error("Doesn't allow required collateral asset.");
             })
           );
-          const payoutCollateralAmt = spendAmt;
+          const payoutCollateralAmt = payoutAmt;
           const reimbursementCollateral = calculateFeeFromRatio(
             redemptionReimbursementRatio,
             payoutCollateralAmt
           );
-          const redeemedIAssetAmt = rationalFloor(
-            rationalDiv(
-              rationalFromInt(payoutCollateralAmt - reimbursementCollateral),
-              price
-            )
+          const redeemedIAssetAmt = iassetValueOfCollateral(
+            payoutCollateralAmt - reimbursementCollateral,
+            price
           );
           const resultVal = addAssets12(
             robUtxo.assets,
@@ -8401,7 +8438,9 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
           return [resultVal, BigInt(allowedAssetIdx)];
         }).exhaustive();
         if (lovelacesAmt3(robOutputVal) < MIN_ROB_COLLATERAL_AMT) {
-          throw new Error("ROB was incorrectly initialised.");
+          throw new Error(
+            "Redeeming more than available or selected ROB was incorrectly initialised."
+          );
         }
         return acc.collectFrom([robUtxo], {
           kind: "self",
@@ -8412,7 +8451,7 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
               iassetRefInputIdx,
               continuingOutputIdx: txOutputsBeforeCount + BigInt(idx),
               sellOrderAllowedAssetsIdx,
-              priceOracleIdx: oracleIdx != null ? { OracleRefInputIdx: oracleIdx } : "OracleVoid"
+              priceOracleIdx: oracleIdx
             }
           })
         }).pay.ToContract(
@@ -8433,6 +8472,85 @@ function buildRedemptionsTx(redemptions, iasset, collateralAsset, price, redempt
     )
   );
 }
+function calculateTotalCollateralForRedemption(iasset, collateralAsset, iassetPrice, allRobs, maxRobsInTx) {
+  return F16.pipe(
+    allRobs,
+    A9.filterMap(([utxo, datum]) => {
+      const isCorrectOrder = match18(datum.orderType).returnType().with(
+        { BuyIAssetOrder: P18.select() },
+        (content) => isSameAssetClass3(content.collateralAsset, collateralAsset) && rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice) && !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice)
+      ).otherwise(() => false);
+      if (toHex12(datum.iasset) !== toHex12(iasset) || !isCorrectOrder) {
+        return O14.none;
+      }
+      const collateralToSpend = robCollateralAmtToSpend(utxo, datum);
+      return O14.some(collateralToSpend);
+    }),
+    // From largest to smallest
+    A9.sort(Ord4.reverse(BigIntOrd)),
+    // We can fit only this number of redemptions with CDP open into a single Tx.
+    A9.takeLeft(maxRobsInTx),
+    sum
+  );
+}
+function randomRobsSubsetSatisfyingTargetCollateral(iasset, collateralAsset, targetCollateralToSpend, iassetPrice, allLrps, maxLrpsInTx, randomiseFn = shuffle) {
+  if (targetCollateralToSpend <= 0n || iassetValueOfCollateral(targetCollateralToSpend, iassetPrice) <= 0n) {
+    throw new Error("Must redeem and payout more than 0.");
+  }
+  const shuffled = randomiseFn(
+    F16.pipe(
+      allLrps,
+      A9.filter(
+        ([utxo, datum]) => toHex12(datum.iasset) === toHex12(iasset) && match18(datum.orderType).with(
+          { BuyIAssetOrder: P18.select() },
+          (content) => isSameAssetClass3(collateralAsset, content.collateralAsset) && rationalToFloat(content.maxPrice) >= rationalToFloat(iassetPrice)
+        ).otherwise(() => false) && !isBuyOrderFullyRedeemed(utxo, datum, iassetPrice)
+      )
+    )
+  );
+  let result = [];
+  let runningSum = 0n;
+  for (let i = 0; i < shuffled.length; i++) {
+    const element = shuffled[i];
+    const lovelacesToSpend = robCollateralAmtToSpend(element[0], element[1]);
+    const remainingToRedeem = targetCollateralToSpend - runningSum;
+    const remainingToPayout = iassetValueOfCollateral(
+      remainingToRedeem,
+      iassetPrice
+    );
+    if (result.length > 0 && remainingToPayout <= 0n) {
+      const last = result[result.length - 1];
+      const lastSummary = robBuyOrderSummary(last[0], last[1], iassetPrice);
+      if (lastSummary.redeemableCollateral < lovelacesToSpend) {
+        result.pop();
+        runningSum -= lastSummary.redeemableCollateral;
+      } else {
+        continue;
+      }
+    }
+    result = insertSorted(
+      result,
+      element,
+      Ord4.contramap(
+        ([utxo, dat]) => robCollateralAmtToSpend(utxo, dat)
+        // From highest to lowest
+      )(Ord4.reverse(BigIntOrd))
+    );
+    runningSum += lovelacesToSpend;
+    if (result.length > maxLrpsInTx) {
+      const popped = result.pop();
+      runningSum -= robCollateralAmtToSpend(popped[0], popped[1]);
+    }
+    if (runningSum >= targetCollateralToSpend) {
+      return result;
+    }
+  }
+  const remainingToSpend = targetCollateralToSpend - runningSum;
+  if (remainingToSpend > 0n && iassetValueOfCollateral(remainingToSpend, iassetPrice) > 0n) {
+    throw new Error("Couldn't achieve target lovelaces");
+  }
+  return result;
+}
 
 // src/contracts/rob/types.ts
 import { Data as Data44 } from "@lucid-evolution/lucid";
@@ -8590,7 +8708,7 @@ async function redeemRob(redemptionRobsData, priceOracleOutRef, iassetOutRef, co
     0n,
     refInputIdxs[2],
     refInputIdxs[1],
-    priceOracleOutRef !== void 0 ? refInputIdxs[3] : null
+    priceOracleOutRef !== void 0 ? { OracleRefInputIdx: refInputIdxs[3] } : "OracleVoid"
   );
   tx.readFrom(allRefInputs);
   return tx;
@@ -8607,12 +8725,12 @@ async function adjustRob(lucid, robOutRef, adjustmentAmt, newLimitPrice, sysPara
     (_) => new Error("Expected a single ROB UTXO.")
   );
   const robDatum = parseRobDatumOrThrow(getInlineDatumOrThrow(robUtxo));
-  if (adjustmentAmt === 0n && isFullyRedeemed(robUtxo, robDatum, sysParams)) {
+  if (adjustmentAmt === 0n && isFullyRedeemed(robUtxo, robDatum, sysParams.cdpParams.cdpAssetSymbol)) {
     throw new Error(
       "When there's no more lovelaces to spend, use close instead of claim."
     );
   }
-  if (adjustmentAmt < 0 && robAmountToSpend(robUtxo, robDatum, sysParams) <= -adjustmentAmt) {
+  if (adjustmentAmt < 0 && robAmtToSpend(robUtxo, robDatum, sysParams.cdpParams.cdpAssetSymbol) <= -adjustmentAmt) {
     throw new Error(
       "Can't adjust negatively by more than available. Also, for adjusting by exactly the amount deposited, a close action should be used instead."
     );
@@ -8733,13 +8851,451 @@ var mkRobValidatorFromSP = (params) => {
   };
 };
 
-// src/contracts/price-oracle/transactions.ts
+// src/contracts/rob-leverage/transactions.ts
 import {
   addAssets as addAssets14,
+  slotToUnixTime as slotToUnixTime10,
   Data as Data45,
   fromHex as fromHex14,
+  getInputIndices as getInputIndices5
+} from "@lucid-evolution/lucid";
+
+// src/contracts/rob-leverage/helpers.ts
+import { array as A11, function as F18 } from "fp-ts";
+import { Decimal } from "decimal.js";
+var MAX_REDEMPTIONS_WITH_CDP_OPEN = 4;
+function approximateLeverageRedemptions(baseCollateral, targetLeverage, redemptionReimbursementRatio, debtMintingFeeRatio) {
+  const debtMintingFeeRatioDecimal = Decimal(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator
+  );
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementRatio.numerator
+  ).div(redemptionReimbursementRatio.denominator);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const bExFees = Decimal(baseCollateral).mul(targetLeverage).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = {
+    numerator: fromDecimal(Decimal(baseCollateral).add(bExFees)),
+    denominator: fromDecimal(b)
+  };
+  return {
+    leverage: targetLeverage,
+    collateralRatio,
+    redeemedCollateral: fromDecimal(bExFees)
+  };
+}
+function summarizeActualLeverageRedemptions(lovelacesForRedemptionWithReimbursement, redemptionReimbursementRatio, iassetPrice, redemptionLrps) {
+  const priceDecimal = Decimal(iassetPrice.numerator).div(
+    iassetPrice.denominator
+  );
+  const reimbRatio = Decimal(redemptionReimbursementRatio.numerator).div(
+    redemptionReimbursementRatio.denominator
+  );
+  const redemptionDetails = F18.pipe(
+    redemptionLrps,
+    A11.reduce(
+      {
+        remainingCollateralToSpend: lovelacesForRedemptionWithReimbursement,
+        redemptions: []
+      },
+      (acc, lrp) => {
+        if (acc.remainingCollateralToSpend <= 0n || iassetValueOfCollateral(
+          acc.remainingCollateralToSpend,
+          iassetPrice
+        ) <= 0n) {
+          return acc;
+        }
+        const collateralToSpend = robCollateralAmtToSpend(lrp[0], lrp[1]);
+        if (collateralToSpend === 0n) {
+          return acc;
+        }
+        const newRemainingCollateral = bigintMax(
+          acc.remainingCollateralToSpend - collateralToSpend,
+          0n
+        );
+        const collateralToSpendInitial = acc.remainingCollateralToSpend - newRemainingCollateral;
+        const finalPayoutIAssets = fromDecimal(
+          Decimal(collateralToSpendInitial).div(priceDecimal).floor().div(Decimal(1).minus(reimbRatio)).floor()
+        );
+        const feeIAssetAmt = calculateFeeFromRatio(
+          redemptionReimbursementRatio,
+          finalPayoutIAssets
+        );
+        const finalCollateralToSpend = rationalFloor(
+          rationalMul(
+            rationalFromInt(finalPayoutIAssets - feeIAssetAmt),
+            iassetPrice
+          )
+        );
+        return {
+          remainingCollateralToSpend: acc.remainingCollateralToSpend - finalCollateralToSpend,
+          redemptions: [
+            ...acc.redemptions,
+            {
+              utxo: lrp[0],
+              iassetsPayoutAmt: finalPayoutIAssets,
+              redeemedCollateral: finalCollateralToSpend,
+              reimbursementIAssetAmt: feeIAssetAmt
+            }
+          ]
+        };
+      }
+    )
+  );
+  const res = F18.pipe(
+    redemptionDetails.redemptions,
+    A11.reduce(
+      {
+        redeemedCollateral: 0n,
+        payoutIAssets: 0n,
+        reimbursementIAssets: 0n
+      },
+      (acc, details) => {
+        return {
+          redeemedCollateral: acc.redeemedCollateral + details.redeemedCollateral,
+          reimbursementIAssets: acc.reimbursementIAssets + details.reimbursementIAssetAmt,
+          payoutIAssets: acc.payoutIAssets + details.iassetsPayoutAmt
+        };
+      }
+    )
+  );
+  return {
+    redemptions: redemptionDetails.redemptions,
+    totalRedeemedCollateral: res.redeemedCollateral,
+    totalReimbursedIAsset: res.reimbursementIAssets,
+    totalIAssetPayout: res.payoutIAssets
+  };
+}
+function calculateCollateralRatioFromLeverage(iasset, collateralAsset, leverage, baseCollateral, iassetPrice, debtMintingFeePercentage, redemptionReimbursementPercentage, allLrps) {
+  const debtMintingFeeRatioDecimal = Decimal(
+    debtMintingFeePercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementPercentage.getOnChainInt
+  ).div(OCD_DECIMAL_UNIT).div(100);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const maxAvailableCollateralForRedemption = calculateTotalCollateralForRedemption(
+    iasset,
+    collateralAsset,
+    iassetPrice,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (leverage <= 1 || baseCollateral <= 0n || maxAvailableCollateralForRedemption <= 0n) {
+    return void 0;
+  }
+  const bExFees = Decimal(baseCollateral).mul(leverage).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b)
+  );
+  const cappedBExFees = Decimal(cappedB).mul(Decimal(1).minus(totalFeeRatio)).floor();
+  const collateralRatio = Decimal(
+    Decimal(baseCollateral).add(cappedBExFees)
+  ).div(cappedB);
+  return {
+    getOnChainInt: fromDecimal(
+      collateralRatio.mul(100n * OCD_DECIMAL_UNIT).floor()
+    )
+  };
+}
+function calculateLeverageFromCollateralRatio(iasset, collateralAsset, collateralRatio, baseCollateral, iassetPrice, debtMintingFeeRatio, redemptionReimbursementRatio, allLrps) {
+  const debtMintingFeeRatioDecimal = Decimal(debtMintingFeeRatio.numerator).div(
+    debtMintingFeeRatio.denominator
+  );
+  const redemptionReimbursementRatioDecimal = Decimal(
+    redemptionReimbursementRatio.numerator
+  ).div(redemptionReimbursementRatio.denominator);
+  const totalFeeRatio = debtMintingFeeRatioDecimal.add(
+    redemptionReimbursementRatioDecimal
+  );
+  const collateralRatioDecimal = Decimal(collateralRatio.numerator).div(
+    collateralRatio.denominator
+  );
+  const maxAvailableCollateralForRedemption = calculateTotalCollateralForRedemption(
+    iasset,
+    collateralAsset,
+    iassetPrice,
+    allLrps,
+    MAX_REDEMPTIONS_WITH_CDP_OPEN
+  );
+  if (collateralRatioDecimal.toNumber() <= 1 || baseCollateral <= 0n || maxAvailableCollateralForRedemption <= 0n) {
+    return void 0;
+  }
+  const theoreticalMaxLeverage = Decimal(Decimal(1).minus(totalFeeRatio)).div(collateralRatioDecimal.minus(1).add(totalFeeRatio)).add(1);
+  const bExFees = theoreticalMaxLeverage.mul(baseCollateral).minus(baseCollateral).floor();
+  const b = bExFees.div(Decimal(1).minus(totalFeeRatio)).floor();
+  const cappedB = bigintMin(
+    maxAvailableCollateralForRedemption,
+    fromDecimal(b)
+  );
+  const cappedBExFees = Decimal(cappedB).mul(Decimal(1).minus(totalFeeRatio)).floor();
+  return Decimal(baseCollateral).add(cappedBExFees).div(baseCollateral).toNumber();
+}
+
+// src/contracts/rob-leverage/transactions.ts
+import { mkAssetsOf as mkAssetsOf11 } from "@3rd-eye-labs/cardano-offchain-common";
+import Decimal2 from "decimal.js";
+async function leverageCdpWithRob(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, collateralAssetOutRef, cdpCreatorOref, interestOracleOref, treasuryOref, sysParams, lucid, allRobs, currentSlot, pythMessage = void 0, pythStateOref = void 0) {
+  const network = lucid.config().network;
+  const currentTime = BigInt(slotToUnixTime10(network, currentSlot));
+  const [pkh, skh] = await addrDetails(lucid);
+  const robScriptRefUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(sysParams.scriptReferences.robValidatorRef)
+    ]),
+    (_2) => new Error("Expected a single ROB Ref Script UTXO")
+  );
+  const cdpCreatorRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.cdpCreatorValidatorRef
+      )
+    ]),
+    (_2) => new Error("Expected a single cdp creator Ref Script UTXO")
+  );
+  const cdpAuthTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.authTokenPolicies.cdpAuthTokenRef
+      )
+    ]),
+    (_2) => new Error("Expected a single cdp auth token policy Ref Script UTXO")
+  );
+  const iAssetTokenPolicyRefScriptUtxo = matchSingle(
+    await lucid.utxosByOutRef([
+      fromSystemParamsScriptRef(
+        sysParams.scriptReferences.iAssetTokenPolicyRef
+      )
+    ]),
+    (_2) => new Error("Expected a single iasset token policy Ref Script UTXO")
+  );
+  const cdpCreatorUtxo = matchSingle(
+    await lucid.utxosByOutRef([cdpCreatorOref]),
+    (_2) => new Error("Expected a single CDP creator UTXO")
+  );
+  const interestOracleUtxo = matchSingle(
+    await lucid.utxosByOutRef([interestOracleOref]),
+    (_2) => new Error("Expected a single interest oracle UTXO")
+  );
+  const interestOracleDatum = parseInterestOracleDatum(
+    getInlineDatumOrThrow(interestOracleUtxo)
+  );
+  const iassetUtxo = matchSingle(
+    await lucid.utxosByOutRef([iassetOutRef]),
+    (_2) => new Error("Expected a single IAsset UTXO")
+  );
+  const iassetDatum = parseIAssetDatumOrThrow(
+    getInlineDatumOrThrow(iassetUtxo)
+  );
+  const collateralAssetUtxo = matchSingle(
+    await lucid.utxosByOutRef([collateralAssetOutRef]),
+    (_2) => new Error("Expected a single collateral asset UTXO")
+  );
+  const collateralAssetDatum = parseCollateralAssetDatumOrThrow(
+    getInlineDatumOrThrow(collateralAssetUtxo)
+  );
+  const [price, _] = await retrieveAdjustedPrice(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    collateralAssetDatum.extraDecimals,
+    priceOracleOutRef,
+    pythMessage,
+    sysParams.pythConfig,
+    lucid
+  );
+  const maxLeverage = calculateLeverageFromCollateralRatio(
+    collateralAssetDatum.iasset,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.maintenanceRatio,
+    baseCollateral,
+    price,
+    iassetDatum.debtMintingFeeRatio,
+    iassetDatum.redemptionReimbursementRatio,
+    allRobs
+  );
+  if (!maxLeverage) {
+    throw new Error("Can't calculate max leverage with those parameters.");
+  }
+  const leverageSummary = approximateLeverageRedemptions(
+    baseCollateral,
+    leverage,
+    iassetDatum.redemptionProcessingFeeRatio,
+    iassetDatum.debtMintingFeeRatio
+  );
+  if (maxLeverage < leverageSummary.leverage) {
+    throw new Error("Can't use more leverage than max.");
+  }
+  if (rationalToFloat(leverageSummary.collateralRatio) < rationalToFloat(collateralAssetDatum.maintenanceRatio)) {
+    throw new Error(
+      "Can't have collateral ratio smaller than maintenance ratio"
+    );
+  }
+  const redemptionDetails = summarizeActualLeverageRedemptions(
+    leverageSummary.redeemedCollateral,
+    iassetDatum.redemptionReimbursementRatio,
+    price,
+    randomRobsSubsetSatisfyingTargetCollateral(
+      iassetDatum.assetName,
+      collateralAssetDatum.collateralAsset,
+      leverageSummary.redeemedCollateral,
+      price,
+      allRobs,
+      MAX_REDEMPTIONS_WITH_CDP_OPEN
+    )
+  );
+  const mintedAmt = fromDecimal(
+    Decimal2(redemptionDetails.totalIAssetPayout).div(
+      Decimal2(1).minus(
+        Decimal2(iassetDatum.debtMintingFeeRatio.numerator).div(
+          iassetDatum.debtMintingFeeRatio.denominator
+        )
+      )
+    ).floor()
+  );
+  const debtMintingFee = calculateFeeFromRatio(
+    iassetDatum.debtMintingFeeRatio,
+    mintedAmt
+  );
+  const collateralAmt = redemptionDetails.totalRedeemedCollateral + baseCollateral;
+  const cdpNftVal = mkAssetsOf11(
+    fromSystemParamsAsset(sysParams.cdpParams.cdpAuthToken),
+    1n
+  );
+  const iassetClass = {
+    currencySymbol: fromHex14(
+      sysParams.cdpParams.cdpAssetSymbol.unCurrencySymbol
+    ),
+    tokenName: iassetDatum.assetName
+  };
+  const iassetTokensVal = mkAssetsOf11(iassetClass, mintedAmt);
+  const refScripts = [
+    cdpCreatorRefScriptUtxo,
+    cdpAuthTokenPolicyRefScriptUtxo,
+    iAssetTokenPolicyRefScriptUtxo,
+    robScriptRefUtxo
+  ];
+  const tx = lucid.newTx().readFrom(refScripts).mintAssets(cdpNftVal, Data45.void()).mintAssets(iassetTokensVal, Data45.void()).pay.ToContract(
+    createScriptAddress(network, sysParams.validatorHashes.cdpHash, skh),
+    {
+      kind: "inline",
+      value: serialiseCdpDatum({
+        cdpOwner: fromHex14(pkh.hash),
+        iasset: iassetDatum.assetName,
+        collateralAsset: collateralAssetDatum.collateralAsset,
+        mintedAmt,
+        cdpFees: {
+          ActiveCDPInterestTracking: {
+            lastSettled: currentTime,
+            unitaryInterestSnapshot: calculateUnitaryInterestSinceOracleLastUpdated(
+              currentTime,
+              interestOracleDatum
+            ) + interestOracleDatum.unitaryInterest
+          }
+        }
+      })
+    },
+    addAssets14(
+      cdpNftVal,
+      mkAssetsOf11(collateralAssetDatum.collateralAsset, collateralAmt)
+    )
+  ).pay.ToContract(
+    cdpCreatorUtxo.address,
+    {
+      kind: "inline",
+      value: serialiseCDPCreatorDatum({
+        creatorInputOref: {
+          outputIndex: BigInt(cdpCreatorUtxo.outputIndex),
+          txHash: fromHex14(cdpCreatorUtxo.txHash)
+        }
+      })
+    },
+    cdpCreatorUtxo.assets
+  );
+  const treasuryRefScriptUtxo = debtMintingFee > 0n ? await treasuryFeeTx(
+    iassetClass,
+    debtMintingFee,
+    0n,
+    lucid,
+    sysParams,
+    tx,
+    cdpCreatorUtxo,
+    treasuryOref
+  ) : void 0;
+  const { interval, referenceInputs: refInputs } = await attachOracle(
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    collateralAssetDatum.priceInfo,
+    priceOracleOutRef,
+    pythStateOref,
+    pythMessage,
+    sysParams.pythConfig,
+    sysParams.cdpCreatorParams.biasTime,
+    currentSlot,
+    lucid,
+    tx
+  );
+  const referenceInputs = [
+    interestOracleUtxo,
+    iassetUtxo,
+    collateralAssetUtxo,
+    ...refInputs
+  ];
+  const refInputsIndices = getInputIndices5(referenceInputs, [
+    ...referenceInputs,
+    ...refScripts,
+    ...treasuryRefScriptUtxo != null ? [treasuryRefScriptUtxo] : []
+  ]);
+  const oracleIdx = priceOracleOutRef !== void 0 ? { OracleRefInputIdx: refInputsIndices[3] } : "OracleVoid";
+  tx.validFrom(interval.validFrom).validTo(interval.validTo).readFrom(referenceInputs).collectFrom([cdpCreatorUtxo], {
+    kind: "self",
+    makeRedeemer: (inputIdx) => {
+      return serialiseCDPCreatorRedeemer({
+        CreateCDP: {
+          cdpOwner: fromHex14(pkh.hash),
+          minted: mintedAmt,
+          collateralAmt,
+          currentTime,
+          creatorInputIdx: inputIdx,
+          creatorOutputIdx: 1n,
+          cdpOutputIdx: 0n,
+          iassetRefInputIdx: refInputsIndices[1],
+          collateralAssetRefInputIdx: refInputsIndices[2],
+          interestOracleRefInputIdx: refInputsIndices[0],
+          priceOracleIdx: oracleIdx
+        }
+      });
+    }
+  });
+  buildRedemptionsTx(
+    redemptionDetails.redemptions.map((r) => [r.utxo, r.iassetsPayoutAmt]),
+    iassetDatum.assetName,
+    collateralAssetDatum.collateralAsset,
+    price,
+    iassetDatum.redemptionReimbursementRatio,
+    sysParams,
+    tx,
+    2n + (debtMintingFee > 0n ? 1n : 0n),
+    refInputsIndices[2],
+    refInputsIndices[1],
+    oracleIdx
+  );
+  return tx;
+}
+
+// src/contracts/price-oracle/transactions.ts
+import {
+  addAssets as addAssets15,
+  Data as Data46,
+  fromHex as fromHex15,
   fromText as fromText10,
-  slotToUnixTime as slotToUnixTime10,
+  slotToUnixTime as slotToUnixTime11,
   validatorToAddress as validatorToAddress2
 } from "@lucid-evolution/lucid";
 
@@ -8766,11 +9322,11 @@ function mkPriceOracleValidator(params) {
 }
 
 // src/contracts/price-oracle/transactions.ts
-import { mkAssetsOf as mkAssetsOf11 } from "@3rd-eye-labs/cardano-offchain-common";
+import { mkAssetsOf as mkAssetsOf12 } from "@3rd-eye-labs/cardano-offchain-common";
 import * as Core2 from "@evolution-sdk/evolution";
 async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, currentSlot, refOutRef, auxiliaryData) {
   const network = lucid.config().network;
-  const now = BigInt(slotToUnixTime10(network, currentSlot));
+  const now = BigInt(slotToUnixTime11(network, currentSlot));
   if (!refOutRef) {
     refOutRef = (await lucid.wallet().getUtxos())[0];
   }
@@ -8787,25 +9343,25 @@ async function startPriceOracleTx(lucid, assetName, startPrice, oracleParams, cu
     ]
   });
   const priceOracleNft = {
-    currencySymbol: fromHex14(oracleNftPolicyId),
-    tokenName: fromHex14(fromText10(assetName))
+    currencySymbol: fromHex15(oracleNftPolicyId),
+    tokenName: fromHex15(fromText10(assetName))
   };
   const oracleValidator = mkPriceOracleValidator(oracleParams);
   const oracleDatum = {
     price: startPrice,
     expirationTime: BigInt(now) + oracleParams.expirationPeriod,
-    auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(Data45.void())
+    auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(Data46.void())
   };
   tx.pay.ToContract(
     validatorToAddress2(lucid.config().network, oracleValidator),
     { kind: "inline", value: serialisePriceOracleDatum(oracleDatum) },
-    addAssets14(mkAssetsOf11(priceOracleNft, 1n))
+    addAssets15(mkAssetsOf12(priceOracleNft, 1n))
   );
   return [tx, priceOracleNft];
 }
 async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, currentSlot, auxiliaryData) {
   const network = lucid.config().network;
-  const currentTime = BigInt(slotToUnixTime10(network, currentSlot));
+  const currentTime = BigInt(slotToUnixTime11(network, currentSlot));
   const priceOracleUtxo = matchSingle(
     await lucid.utxosByOutRef([oracleOref]),
     (_) => new Error("Expected a single price oracle UTXO")
@@ -8824,7 +9380,7 @@ async function feedPriceOracleTx(lucid, oracleOref, newPrice, oracleParams, curr
       value: serialisePriceOracleDatum({
         price: newPrice,
         expirationTime: currentTime + oracleParams.expirationPeriod,
-        auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(Data45.void())
+        auxiliaryData: auxiliaryData ?? Core2.Data.fromCBORHex(Data46.void())
       })
     },
     priceOracleUtxo.assets
@@ -8852,10 +9408,10 @@ async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
 
 // src/contracts/initialize/helpers.ts
 import {
-  addAssets as addAssets15,
+  addAssets as addAssets16,
   credentialToAddress as credentialToAddress4,
-  Data as Data48,
-  fromHex as fromHex15,
+  Data as Data49,
+  fromHex as fromHex16,
   fromText as fromText11,
   mintingPolicyToId as mintingPolicyToId2,
   validatorToScriptHash as validatorToScriptHash4
@@ -8864,7 +9420,7 @@ import {
   assetClassToUnit as assetClassToUnit2,
   assetClassValueOf as assetClassValueOf9,
   lovelacesAmt as lovelacesAmt4,
-  mkAssetsOf as mkAssetsOf12,
+  mkAssetsOf as mkAssetsOf13,
   mkLovelacesOf as mkLovelacesOf7
 } from "@3rd-eye-labs/cardano-offchain-common";
 
@@ -8899,8 +9455,8 @@ var _iassetValidator = {
 };
 
 // src/contracts/iasset/scripts.ts
-import { Data as Data47 } from "@lucid-evolution/lucid";
-var IAssetScriptParamsSchema = Data47.Object({
+import { Data as Data48 } from "@lucid-evolution/lucid";
+var IAssetScriptParamsSchema = Data48.Object({
   upgradeToken: AssetClassSchema2,
   versionRecordToken: AssetClassSchema2
 });
@@ -8909,7 +9465,7 @@ var mkIAssetValidatorFromSP = (params) => {
   return {
     type: "PlutusV3",
     script: applyParamsToScript17(_iassetValidator.cborHex, [
-      Data47.castTo(
+      Data48.castTo(
         {
           upgradeToken: fromSystemParamsAssetLucid(params.upgradeToken),
           versionRecordToken: fromSystemParamsAssetLucid(
@@ -8926,7 +9482,7 @@ var mkIAssetValidatorFromSP = (params) => {
 import { match as match20 } from "ts-pattern";
 
 // tests/test-helpers.ts
-import { array as A11, function as F18, option as O16 } from "fp-ts";
+import { array as A12, function as F19, option as O16 } from "fp-ts";
 async function runAndAwaitTxBuilder(lucid, transaction, extraSigners = []) {
   const bTx = await transaction.complete();
   const signatures = [await bTx.partialSign.withWallet()];
@@ -8989,15 +9545,15 @@ async function mintOneTimeToken(lucid, tokenName, amount) {
 async function mintOneTimeAsset(lucid, tokenName, amount) {
   const policyId = await mintOneTimeToken(lucid, fromText11(tokenName), amount);
   return {
-    currencySymbol: fromHex15(policyId),
-    tokenName: fromHex15(fromText11(tokenName))
+    currencySymbol: fromHex16(policyId),
+    tokenName: fromHex16(fromText11(tokenName))
   };
 }
 function deriveAuthToken(parent, tokenName) {
   const policy = mkAuthTokenPolicy(parent, fromText11(tokenName));
   return {
-    currencySymbol: fromHex15(mintingPolicyToId2(policy)),
-    tokenName: fromHex15(fromText11(tokenName))
+    currencySymbol: fromHex16(mintingPolicyToId2(policy)),
+    tokenName: fromHex16(fromText11(tokenName))
   };
 }
 async function initScriptRef(lucid, validator) {
@@ -9024,7 +9580,7 @@ async function initCollector(lucid, collectorParams, numCollectors) {
       ),
       {
         kind: "inline",
-        value: Data48.void()
+        value: Data49.void()
       }
     );
   }
@@ -9035,7 +9591,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
   const interestCollectionAdminDatum = {
     admin_permissions: {
       Signature: {
-        keyHash: fromHex15(pkh.hash)
+        keyHash: fromHex16(pkh.hash)
       }
     }
   };
@@ -9047,7 +9603,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
         kind: "inline",
         value: serialiseInterestCollectionDatum(interestCollectionAdminDatum)
       },
-      mkAssetsOf12(multisigUtxoNft, 1n)
+      mkAssetsOf13(multisigUtxoNft, 1n)
     )
   );
   const interestCollectionUtxoDeploymentTx = lucid.newTx();
@@ -9070,7 +9626,7 @@ async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
         ),
         type: "Script"
       }),
-      { kind: "inline", value: Data48.void() },
+      { kind: "inline", value: Data49.void() },
       {
         [cdpCreatorParams.cdpCreatorNft[0].unCurrencySymbol + fromText11(cdpCreatorParams.cdpCreatorNft[1].unTokenName)]: 1n
       }
@@ -9086,16 +9642,16 @@ async function initTreasury(lucid, treasuryParams, daoAsset, indyAsset, treasury
   );
   const tx = lucid.newTx().pay.ToContract(
     treasuryAddr,
-    { kind: "inline", value: Data48.void() },
-    addAssets15(
-      mkAssetsOf12(daoAsset, 1n),
-      mkAssetsOf12(indyAsset, treasuryIndyAmount)
+    { kind: "inline", value: Data49.void() },
+    addAssets16(
+      mkAssetsOf13(daoAsset, 1n),
+      mkAssetsOf13(indyAsset, treasuryIndyAmount)
     )
   );
   for (let i = 0; i < Number(numTreasuryCollectors); i++) {
     tx.pay.ToContract(treasuryAddr, {
       kind: "inline",
-      value: Data48.void()
+      value: Data49.void()
     });
   }
   await submitTx(lucid, tx);
@@ -9140,10 +9696,10 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
     return Promise.resolve({
       info: {
         DeferredValidation: {
-          feedValHash: fromHex15(
+          feedValHash: fromHex16(
             getPythFeedConfig(
               pythConfig,
-              fromHex15(fromText11(iasset.name)),
+              fromHex16(fromText11(iasset.name)),
               collateralAsset.collateralAsset
             ).pythFeedValHash
           )
@@ -9154,7 +9710,7 @@ async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, py
   }).exhaustive();
 }
 async function initializeAsset(lucid, iassetParams, iassetToken, collateralAssetAuthToken, cdpAuthToken, cdpParams, stableswapValidatorHash, stabilityPoolParams, stabilityPoolToken, asset, pythConfig, currentSlot) {
-  const iassetName = fromHex15(fromText11(asset.name));
+  const iassetName = fromHex16(fromText11(asset.name));
   const collateralAssetInfos = [];
   for (const collateralAsset of asset.collateralAssets) {
     const [pkh, _] = await addrDetails(lucid);
@@ -9202,7 +9758,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
           CollateralAssetContent: collateralAssetContent
         })
       },
-      mkAssetsOf12(collateralAssetAuthToken, 1n)
+      mkAssetsOf13(collateralAssetAuthToken, 1n)
     );
     await submitTx(lucid, collateralAssetTx);
     collateralAssetInfos.push({
@@ -9220,11 +9776,11 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       redemptionFeeRatio: stableswapPool.redemptionFeeRatio,
       mintingEnabled: stableswapPool.mintingEnabled,
       redemptionEnabled: stableswapPool.redemptionEnabled,
-      feeManager: stableswapPool.feeManager ? fromHex15(stableswapPool.feeManager) : null,
+      feeManager: stableswapPool.feeManager ? fromHex16(stableswapPool.feeManager) : null,
       minMintOrderAmount: stableswapPool.minMintOrderAmount,
       minRedemptionOrderAmount: stableswapPool.minRedemptionOrderAmount,
       iasset: iassetName,
-      stableswapValHash: fromHex15(stableswapValidatorHash)
+      stableswapValHash: fromHex16(stableswapValidatorHash)
     };
     await submitTx(
       lucid,
@@ -9237,7 +9793,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
           kind: "inline",
           value: serialiseStableswapPoolDatum(stableswapPoolDatum)
         },
-        mkAssetsOf12(cdpAuthToken, 1n)
+        mkAssetsOf13(cdpAuthToken, 1n)
       )
     );
   }
@@ -9250,7 +9806,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     redemptionReimbursementRatio: asset.redemptionReimbursementRatio,
     redemptionProcessingFeeRatio: asset.redemptionProcessingFeeRatio,
     firstIAsset: asset.firstAsset,
-    nextIAsset: asset.nextAsset ? fromHex15(fromText11(asset.nextAsset)) : null
+    nextIAsset: asset.nextAsset ? fromHex16(fromText11(asset.nextAsset)) : null
   };
   const assetTx = lucid.newTx().pay.ToContract(
     createScriptAddress(
@@ -9261,11 +9817,11 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       kind: "inline",
       value: serialiseIAssetDatum({ IAssetContent: iassetDatum })
     },
-    mkAssetsOf12(iassetToken, 1n)
+    mkAssetsOf13(iassetToken, 1n)
   );
   await submitTx(lucid, assetTx);
   const stabilityPoolDatum = {
-    iasset: fromHex15(fromText11(asset.name)),
+    iasset: fromHex16(fromText11(asset.name)),
     state: initSpState,
     assetStates: []
   };
@@ -9280,7 +9836,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       kind: "inline",
       value: serialiseStabilityPoolDatum({ StabilityPool: stabilityPoolDatum })
     },
-    mkAssetsOf12(stabilityPoolToken, 1n)
+    mkAssetsOf13(stabilityPoolToken, 1n)
   );
   await submitTx(lucid, spTx);
   return {
@@ -9302,7 +9858,7 @@ async function initGovernance(lucid, governanceParams, govToken, initialAssets,
       type: "Script"
     }),
     { kind: "inline", value: serialiseGovDatum(datum) },
-    mkAssetsOf12(govToken, 1n)
+    mkAssetsOf13(govToken, 1n)
   );
   await submitTx(lucid, tx);
 }
@@ -9319,16 +9875,16 @@ async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
     {
       [policyId + fromText11(tokenName)]: amount
     },
-    Data48.void()
+    Data49.void()
   );
   await submitTx(lucid, tx);
 }
 
 // src/contracts/initialize/actions.ts
 import {
-  addAssets as addAssets16,
+  addAssets as addAssets17,
   credentialToRewardAddress as credentialToRewardAddress4,
-  fromHex as fromHex17,
+  fromHex as fromHex18,
   fromText as fromText13,
   mintingPolicyToId as mintingPolicyToId3,
   scriptHashToCredential as scriptHashToCredential4,
@@ -9336,7 +9892,7 @@ import {
   validatorToScriptHash as validatorToScriptHash6
 } from "@lucid-evolution/lucid";
 import {
-  mkAssetsOf as mkAssetsOf14,
+  mkAssetsOf as mkAssetsOf15,
   mkLovelacesOf as mkLovelacesOf8
 } from "@3rd-eye-labs/cardano-offchain-common";
 
@@ -9363,17 +9919,17 @@ function mkIAssetTokenPolicy(ac) {
 import { applyParamsToScript as applyParamsToScript19 } from "@lucid-evolution/lucid";
 
 // src/contracts/stableswap/types.ts
-import { Data as Data49 } from "@lucid-evolution/lucid";
-var StableswapParamsSchema = Data49.Object({
-  iassetSymbol: Data49.Bytes(),
+import { Data as Data50 } from "@lucid-evolution/lucid";
+var StableswapParamsSchema = Data50.Object({
+  iassetSymbol: Data50.Bytes(),
   cdpToken: AssetClassSchema2,
   versionRecordToken: AssetClassSchema2,
-  cdpValHash: Data49.Bytes(),
-  treasuryValHash: Data49.Bytes()
+  cdpValHash: Data50.Bytes(),
+  treasuryValHash: Data50.Bytes()
 });
 var StableswapParams = StableswapParamsSchema;
 function castStableswapParams(params) {
-  return Data49.castTo(params, StableswapParams);
+  return Data50.castTo(params, StableswapParams);
 }
 
 // src/validators/stableswap-validator.ts
@@ -9434,7 +9990,7 @@ import { match as match21 } from "ts-pattern";
 import {
   credentialToAddress as credentialToAddress5,
   credentialToRewardAddress as credentialToRewardAddress3,
-  fromHex as fromHex16,
+  fromHex as fromHex17,
   fromText as fromText12,
   validatorToScriptHash as validatorToScriptHash5
 } from "@lucid-evolution/lucid";
@@ -9453,14 +10009,14 @@ var alwaysSucceedValidator = {
 };
 
 // tests/pyth/endpoints.ts
-import { mkAssetsOf as mkAssetsOf13 } from "@3rd-eye-labs/cardano-offchain-common";
+import { mkAssetsOf as mkAssetsOf14 } from "@3rd-eye-labs/cardano-offchain-common";
 var TEST_TRUSTED_SIGNER_PUB_KEY = "4a50d7c3d16b2be5c16ba996109a455a34cce08a81b3e15b86ef407e2f72e71f";
 async function initPyth(lucid) {
   const pythStateName = fromText12("Pyth State");
   const pythStatePolicyId = await mintOneTimeToken(lucid, pythStateName, 1n);
   const pythStateAsset = {
-    currencySymbol: fromHex16(pythStatePolicyId),
-    tokenName: fromHex16(pythStateName)
+    currencySymbol: fromHex17(pythStatePolicyId),
+    tokenName: fromHex17(pythStateName)
   };
   const alwaysSucceedsValidatorHash = validatorToScriptHash5(
     alwaysSucceedValidator
@@ -9468,14 +10024,14 @@ async function initPyth(lucid) {
   const pythStateDatum = {
     // The governance doesn't matter for the purpose of testing, so we can use any values
     governance: {
-      wormhole: fromHex16(""),
+      wormhole: fromHex17(""),
       emitterChain: 0n,
-      emitterAddress: fromHex16(""),
+      emitterAddress: fromHex17(""),
       seenSequence: 0n
     },
     trustedSigners: /* @__PURE__ */ new Map([
       [
-        fromHex16(TEST_TRUSTED_SIGNER_PUB_KEY),
+        fromHex17(TEST_TRUSTED_SIGNER_PUB_KEY),
         {
           lower_bound: {
             bound_type: {
@@ -9495,7 +10051,7 @@ async function initPyth(lucid) {
     deprecatedWithdrawScripts: /* @__PURE__ */ new Map(),
     // For the purpose of testing, we use the always succeeds validator to validate the Pyth Messages.
     // This means the message signature checking will always succeed for the purpose of emulation testing.
-    withdraw_script: fromHex16(alwaysSucceedsValidatorHash)
+    withdraw_script: fromHex17(alwaysSucceedsValidatorHash)
   };
   await runAndAwaitTxBuilder(
     lucid,
@@ -9505,7 +10061,7 @@ async function initPyth(lucid) {
         type: "Script"
       }),
       { kind: "inline", value: serialisePythStateDatum(pythStateDatum) },
-      mkAssetsOf13(pythStateAsset, 1n),
+      mkAssetsOf14(pythStateAsset, 1n),
       alwaysSucceedValidator
     )
   );
@@ -9608,8 +10164,8 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
     }
   });
   const versionRecordToken = {
-    currencySymbol: fromHex17(mintingPolicyToId3(versionRecordTokenPolicy)),
-    tokenName: fromHex17(fromText13(tn.versionRecord))
+    currencySymbol: fromHex18(mintingPolicyToId3(versionRecordTokenPolicy)),
+    tokenName: fromHex18(fromText13(tn.versionRecord))
   };
   const versionRegistryValidator = mkVersionRegistryValidator();
   const versionRegistryValHash = validatorToScriptHash6(
@@ -9808,8 +10364,8 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
         lucid,
         lucid.newTx().pay.ToAddress(
           await lucid.wallet().address(),
-          addAssets16(
-            mkAssetsOf14(iassetToken, 1n),
+          addAssets17(
+            mkAssetsOf15(iassetToken, 1n),
             mkLovelacesOf8(BigInt(totalCollateralAssetsCount) * 5000000n)
           )
         )
@@ -9826,8 +10382,8 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
         lucid,
         lucid.newTx().pay.ToAddress(
           await lucid.wallet().address(),
-          addAssets16(
-            mkAssetsOf14(cdpCreatorAsset, 1n),
+          addAssets17(
+            mkAssetsOf15(cdpCreatorAsset, 1n),
             mkLovelacesOf8(BigInt(totalStablePoolsCount) * 5000000n)
           )
         )
@@ -10108,7 +10664,7 @@ async function init(lucid, defaultInitialAssets, currentSlot, mkPythBasedAssets
 }
 
 // src/contracts/stableswap/helpers.ts
-import { fromHex as fromHex18, fromText as fromText14 } from "@lucid-evolution/lucid";
+import { fromHex as fromHex19, fromText as fromText14 } from "@lucid-evolution/lucid";
 
 // src/contracts/stableswap/types-new.ts
 import {
@@ -10116,10 +10672,10 @@ import {
   AssetClassSchema as AssetClassSchema8,
   OutputReferenceSchema as OutputReferenceSchema7
 } from "@3rd-eye-labs/cardano-offchain-common";
-import { TSchema as TSchema20, Data as Data50 } from "@evolution-sdk/evolution";
-import { option as O17, function as F19 } from "fp-ts";
+import { TSchema as TSchema20, Data as Data51 } from "@evolution-sdk/evolution";
+import { option as O17, function as F20 } from "fp-ts";
 import { Schema as Schema4 } from "effect";
-var OpaqueData4 = Schema4.typeSchema(Data50.DataSchema);
+var OpaqueData4 = Schema4.typeSchema(Data51.DataSchema);
 var StableswapOrderDatumSchema = TSchema20.Struct({
   iasset: TSchema20.ByteArray,
   collateralAsset: AssetClassSchema8,
@@ -10152,7 +10708,7 @@ var StableswapOutputDatumSchema = TSchema20.Tuple([
   OutputReferenceSchema7
 ]);
 function serialiseStableswapOrderDatum(d) {
-  return Data50.withSchema(
+  return Data51.withSchema(
     StableswapOrderDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
@@ -10160,7 +10716,7 @@ function serialiseStableswapOrderDatum(d) {
 function parseStableswapOrderDatum(datum) {
   try {
     return O17.some(
-      Data50.withSchema(
+      Data51.withSchema(
         StableswapOrderDatumSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(datum)
@@ -10170,21 +10726,21 @@ function parseStableswapOrderDatum(datum) {
   }
 }
 function parseStableswapOrderDatumOrThrow(datum) {
-  return F19.pipe(
+  return F20.pipe(
     parseStableswapOrderDatum(datum),
     O17.match(() => {
       throw new Error("Expected a Stableswap Order datum.");
-    }, F19.identity)
+    }, F20.identity)
   );
 }
 function serialiseStableswapOutputDatum(d) {
-  return Data50.withSchema(
+  return Data51.withSchema(
     StableswapOutputDatumSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(d);
 }
 function serialiseStableswapOrderRedeemer(r) {
-  return Data50.withSchema(
+  return Data51.withSchema(
     StableswapOrderRedeemerSchema,
     DEFAULT_SCHEMA_OPTIONS
   ).toCBORHex(r);
@@ -10192,7 +10748,7 @@ function serialiseStableswapOrderRedeemer(r) {
 function parseStableswapOrderRedeemer(redeemerCborHex) {
   try {
     return O17.some(
-      Data50.withSchema(
+      Data51.withSchema(
         StableswapOrderRedeemerSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(redeemerCborHex)
@@ -10202,36 +10758,36 @@ function parseStableswapOrderRedeemer(redeemerCborHex) {
   }
 }
 function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
-  return F19.pipe(
+  return F20.pipe(
     parseStableswapOrderRedeemer(redeemerCborHex),
     O17.match(() => {
       throw new Error("Expected a Stableswap Order redeemer.");
-    }, F19.identity)
+    }, F20.identity)
   );
 }
 
 // src/contracts/stableswap/helpers.ts
-import { Data as Data51 } from "@evolution-sdk/evolution";
+import { Data as Data52 } from "@evolution-sdk/evolution";
 var BASE_MAX_EXECUTION_FEE = 1000000n;
 function createDestinationDatum(datum, outRef) {
   if (!datum) {
     return serialiseStableswapOutputDatum([
-      fromHex18(fromText14("IndigoStableswap")),
+      fromHex19(fromText14("IndigoStableswap")),
       {
-        txHash: fromHex18(outRef.txHash),
+        txHash: fromHex19(outRef.txHash),
         outputIndex: BigInt(outRef.outputIndex)
       }
     ]);
   }
-  return Data51.toCBORHex(datum);
+  return Data52.toCBORHex(datum);
 }
 
 // src/contracts/stableswap/transactions.ts
 import {
-  addAssets as addAssets17,
+  addAssets as addAssets18,
   credentialToAddress as credentialToAddress6,
-  Data as Data52,
-  fromHex as fromHex19,
+  Data as Data53,
+  fromHex as fromHex20,
   fromText as fromText15,
   paymentCredentialOf as paymentCredentialOf3,
   sortUTxOs as sortUTxOs2,
@@ -10243,32 +10799,32 @@ import {
   addressToBech32 as addressToBech323,
   getInlineDatumOrThrow as getInlineDatumOrThrow6,
   matchSingle as matchSingle4,
-  mkAssetsOf as mkAssetsOf15,
+  mkAssetsOf as mkAssetsOf16,
   mkLovelacesOf as mkLovelacesOf9,
   lovelacesAmt as lovelacesAmt5,
   isSameOutRef as isSameOutRef2,
   assetClassValueOf as assetClassValueOf10
 } from "@3rd-eye-labs/cardano-offchain-common";
-import { array as A12, function as F20 } from "fp-ts";
+import { array as A13, function as F21 } from "fp-ts";
 import { isEmpty } from "fp-ts/lib/Array";
 async function createStableswapOrder(iasset, collateralAsset, amount, minting, poolDatum, params, lucid, destinationAddress, destinationInlineDatum, maxExecutionFee = BASE_MAX_EXECUTION_FEE, additionalLovelaces = 0n, maxFeeRatio) {
   const myAddress = await lucid.wallet().address();
   const pkh = paymentCredentialOf3(myAddress);
   const datum = {
-    iasset: fromHex19(fromText15(iasset)),
+    iasset: fromHex20(fromText15(iasset)),
     collateralAsset,
-    owner: fromHex19(pkh.hash),
+    owner: fromHex20(pkh.hash),
     destination: addressFromBech323(destinationAddress ?? myAddress),
     destinationInlineDatum: destinationInlineDatum ?? null,
     maxExecutionFee,
     maxFeeRatio: maxFeeRatio ?? (minting ? poolDatum.mintingFeeRatio : poolDatum.redemptionFeeRatio)
   };
-  const assetsToSwap = minting ? mkAssetsOf15(collateralAsset, amount) : mkAssetsOf15(
+  const assetsToSwap = minting ? mkAssetsOf16(collateralAsset, amount) : mkAssetsOf16(
     {
-      currencySymbol: fromHex19(
+      currencySymbol: fromHex20(
         params.stableswapParams.iassetSymbol.unCurrencySymbol
       ),
-      tokenName: fromHex19(fromText15(iasset))
+      tokenName: fromHex20(fromText15(iasset))
     },
     amount
   );
@@ -10296,7 +10852,7 @@ async function createStableswapOrder(iasset, collateralAsset, amount, minting, p
       kind: "inline",
       value: serialiseStableswapOrderDatum(datum)
     },
-    addAssets17(
+    addAssets18(
       assetsToSwap,
       mkLovelacesOf9(
         roundedExpectedOutputLovelaces + maxExecutionFee + additionalLovelaces
@@ -10364,7 +10920,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     getInlineDatumOrThrow6(mainOrderUtxo)
   );
   const iassetAc = {
-    currencySymbol: fromHex19(
+    currencySymbol: fromHex20(
       sysParams.stableswapParams.iassetSymbol.unCurrencySymbol
     ),
     tokenName: mainOrderDatum.iasset
@@ -10510,9 +11066,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       }
     }
   );
-  const totalSwapInfo = F20.pipe(
+  const totalSwapInfo = F21.pipe(
     ordersInfo,
-    A12.reduce(
+    A13.reduce(
       {
         suppliedCollateralAsset: 0n,
         suppliedIasset: 0n,
@@ -10554,17 +11110,17 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       kind: "inline",
       value: serialiseStableswapPoolDatum(stableswapPoolDatum)
     },
-    collateralAmtChangePool != 0n ? addAssets17(
+    collateralAmtChangePool != 0n ? addAssets18(
       stableswapPoolUtxo.assets,
-      mkAssetsOf15(collateralAc, collateralAmtChangePool)
+      mkAssetsOf16(collateralAc, collateralAmtChangePool)
     ) : stableswapPoolUtxo.assets
   ).setMinFee(2055720n);
   if (amountToMint !== 0n) {
-    tx.mintAssets(mkAssetsOf15(iassetAc, amountToMint), Data52.void());
+    tx.mintAssets(mkAssetsOf16(iassetAc, amountToMint), Data53.void());
   }
-  F20.pipe(
+  F21.pipe(
     ordersInfo,
-    A12.reduce(tx, (acc, orderInfo) => {
+    A13.reduce(tx, (acc, orderInfo) => {
       return acc.collectFrom(
         [orderInfo.utxo],
         isSameOutRef2(orderInfo.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
@@ -10588,13 +11144,13 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
             orderInfo.utxo
           )
         },
-        addAssets17(
+        addAssets18(
           // Currently, we always take the max execution fee from the order utxo.
           // This can be improved so that we take the actual execution fee.
           mkLovelacesOf9(
             lovelacesAmt5(orderInfo.utxo.assets) - orderInfo.datum.maxExecutionFee
           ),
-          orderInfo.swapInfo.owedIasset > 0 ? mkAssetsOf15(iassetAc, orderInfo.swapInfo.owedIasset) : mkAssetsOf15(
+          orderInfo.swapInfo.owedIasset > 0 ? mkAssetsOf16(iassetAc, orderInfo.swapInfo.owedIasset) : mkAssetsOf16(
             collateralAc,
             orderInfo.swapInfo.owedCollateralAsset
           )
@@ -10694,6 +11250,7 @@ export {
   InterestOracleDatumSchema,
   InterestOracleParamsSchema,
   MAX_E2S2S_ENTRIES_COUNT,
+  MAX_REDEMPTIONS_WITH_CDP_OPEN,
   MIN_ROB_COLLATERAL_AMT,
   ONE_DAY,
   ONE_HOUR,
@@ -10728,6 +11285,7 @@ export {
   adjustStakingPosition,
   alwaysFailValidator,
   annulRequest,
+  approximateLeverageRedemptions,
   attachOracle,
   balance,
   batchCollectInterest,
@@ -10738,8 +11296,11 @@ export {
   burnCdp,
   calculateAccruedInterest,
   calculateAdaReward,
+  calculateCollateralRatioFromLeverage,
   calculateIAssetRedemptionAmt,
+  calculateLeverageFromCollateralRatio,
   calculateMinCollateralCappedIAssetRedemptionAmt,
+  calculateTotalCollateralForRedemption,
   calculateUnitaryInterest,
   calculateUnitaryInterestSinceOracleLastUpdated,
   cancelRob,
@@ -10805,9 +11366,9 @@ export {
   getAssetClassComparisonStr,
   getInlineDatumOrThrow,
   getPythFeedConfig,
-  getRandomElement,
   getUpdatedAccountDeposit,
   handleOracleForCollateralAsset,
+  iassetValueOfCollateral,
   init,
   initCDPCreator,
   initCollector,
@@ -10821,8 +11382,10 @@ export {
   initTreasury,
   initializeAsset,
   insertSorted,
+  isBuyOrderFullyRedeemed,
   isFullyRedeemed,
   isSameEpochToScaleKey,
+  leverageCdpWithRob,
   liquidateCdp,
   liquidationHelper,
   loadSystemParamsFromFile,
@@ -10886,10 +11449,6 @@ export {
   parseIAssetDatumOrThrow,
   parseInterestCollectionDatum,
   parseInterestOracleDatum,
-  parsePollManager,
-  parsePollManagerOrThrow,
-  parsePollShard,
-  parsePollShardOrThrow,
   parsePriceOracleDatum,
   parsePythStateDatum,
   parseRobDatum,
@@ -10910,8 +11469,8 @@ export {
   parseStakingPosition,
   parseStakingPositionOrThrow,
   partitionEpochToScaleToSums,
-  pollPassQuorum,
   processSpRequest,
+  randomRobsSubsetSatisfyingTargetCollateral,
   rationalAdd,
   rationalCeil,
   rationalDiv,
@@ -10930,7 +11489,10 @@ export {
   requestSpAccountClosure,
   requestSpAccountCreation,
   rewardSnapshotPrecision,
-  robAmountToSpend,
+  robAmtToSpend,
+  robBuyOrderSummary,
+  robCollateralAmtToSpend,
+  robIAssetAmtToSpend,
   runCreateScriptRefTx,
   runOneShotMintTx,
   scriptRef,
@@ -10947,9 +11509,6 @@ export {
   serialiseInterestCollectionDatum,
   serialiseInterestCollectionRedeemer,
   serialiseInterestOracleDatum,
-  serialisePollDatum,
-  serialisePollManagerRedeemer,
-  serialisePollShardRedeemer,
   serialisePriceOracleDatum,
   serialisePriceOracleRedeemer,
   serialisePythFeedParams,
@@ -10978,6 +11537,7 @@ export {
   startPriceOracleTx,
   submitTx,
   sum,
+  summarizeActualLeverageRedemptions,
   toAssetClassFromLucid,
   toDataDerivedPythPrice,
   toSystemParamsAsset,