@indigo-labs/indigo-sdk 0.2.34 → 0.2.36

package/dist/index.js

@@ -208,6 +208,7 @@ __export(index_exports, {
   randomLrpsSubsetSatisfyingTargetLovelaces: () => randomLrpsSubsetSatisfyingTargetLovelaces,
   redeemCdp: () => redeemCdp,
   redeemLrp: () => redeemLrp,
+  resolveUtxo: () => resolveUtxo,
   rewardSnapshotPrecision: () => rewardSnapshotPrecision,
   runCreateScriptRefTx: () => runCreateScriptRefTx,
   runOneShotMintTx: () => runOneShotMintTx,
@@ -275,6 +276,33 @@ function fromSysParamsScriptCredential(cred) {
 
 // src/utils/lucid-utils.ts
 var import_lucid2 = require("@lucid-evolution/lucid");
+
+// src/utils/utils.ts
+var fs = __toESM(require("fs"));
+var import_ts_pattern = require("ts-pattern");
+function matchSingle(xs, mkErr) {
+  return (0, import_ts_pattern.match)(xs).with([import_ts_pattern.P.select()], (res) => res).otherwise(() => {
+    throw mkErr(xs);
+  });
+}
+function loadSystemParamsFromFile(file) {
+  return JSON.parse(fs.readFileSync(file, "utf-8"));
+}
+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/lucid-utils.ts
+async function resolveUtxo(input, lucid, errorMsg = "Expected a single UTXO") {
+  if ("address" in input) {
+    return input;
+  }
+  return matchSingle(
+    await lucid.utxosByOutRef([input]),
+    (_) => new Error(errorMsg)
+  );
+}
 function getInlineDatumOrThrow(utxo) {
   if (utxo.datum != null) {
     return utxo.datum;
@@ -313,22 +341,6 @@ function balance(utxos) {
   return utxos.reduce((acc, utxo) => (0, import_lucid2.addAssets)(acc, utxo.assets), {});
 }
 
-// src/utils/utils.ts
-var fs = __toESM(require("fs"));
-var import_ts_pattern = require("ts-pattern");
-function matchSingle(xs, mkErr) {
-  return (0, import_ts_pattern.match)(xs).with([import_ts_pattern.P.select()], (res) => res).otherwise(() => {
-    throw mkErr(xs);
-  });
-}
-function loadSystemParamsFromFile(file) {
-  return JSON.parse(fs.readFileSync(file, "utf-8"));
-}
-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/contracts/cdp/types.ts
 var import_lucid6 = require("@lucid-evolution/lucid");
 
@@ -1440,10 +1452,11 @@ function serialiseCollectorRedeemer(redeemer) {
 }
 
 // src/contracts/collector/transactions.ts
-async function collectorFeeTx(fee, lucid, params, tx, collectorOref) {
-  const collectorUtxo = matchSingle(
-    await lucid.utxosByOutRef([collectorOref]),
-    (_) => new Error("Expected a single collector UTXO")
+async function collectorFeeTx(fee, lucid, params, tx, collector) {
+  const collectorUtxo = await resolveUtxo(
+    collector,
+    lucid,
+    "Expected a single collector UTXO"
   );
   const collectorRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -1493,11 +1506,12 @@ function serialiseTreasuryRedeemer(redeemer) {
 }
 
 // src/contracts/treasury/transactions.ts
-async function treasuryFeeTx(fee, lucid, sysParams, tx, treasuryOref) {
+async function treasuryFeeTx(fee, lucid, sysParams, tx, treasury) {
   if (fee <= 0n) return;
-  const treasuryUtxo = matchSingle(
-    await lucid.utxosByOutRef([treasuryOref]),
-    (_) => new Error("Expected a single treasury UTXO")
+  const treasuryUtxo = await resolveUtxo(
+    treasury,
+    lucid,
+    "Expected a single treasury UTXO"
   );
   const treasuryRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -1522,7 +1536,7 @@ async function treasuryFeeTx(fee, lucid, sysParams, tx, treasuryOref) {
 }
 
 // src/contracts/cdp/transactions.ts
-async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, lucid, currentSlot) {
+async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreator, iasset, priceOracle, interestOracle, collector, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const [pkh, skh] = await addrDetails(lucid);
@@ -1550,30 +1564,34 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     ]),
     (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
   );
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error("Expected a single iasset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single iasset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
   );
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
   const priceOracleDatum = parsePriceOracleDatum(
     getInlineDatumOrThrow(priceOracleUtxo)
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "Expected a single interest oracle UTXO"
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
   );
-  const cdpCreatorUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpCreatorOref]),
-    (_) => new Error("Expected a single CDP creator UTXO")
+  const cdpCreatorUtxo = await resolveUtxo(
+    cdpCreator,
+    lucid,
+    "Expected a single CDP creator UTXO"
   );
   (0, import_ts_pattern7.match)(iassetDatum.price).with({ Delisted: import_ts_pattern7.P.any }, () => {
     throw new Error("Can't open CDP of delisted asset");
@@ -1640,11 +1658,11 @@ async function openCdp(collateralAmount, mintedAmount, sysParams, cdpCreatorOref
     mintedAmount * priceOracleDatum.price.getOnChainInt / 1000000n
   );
   if (debtMintingFee > 0) {
-    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collectorOref);
+    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collector);
   }
   return tx;
 }
-async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, sysParams, lucid, currentSlot) {
+async function adjustCdp(collateralAmount, mintAmount, cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
@@ -1653,33 +1671,30 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
     ]),
     (_) => new Error("Expected a single cdp Ref Script UTXO")
   );
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error("Expected a single cdp UTXO")
-  );
+  const cdpUtxo = await resolveUtxo(cdp, lucid, "Expected a single cdp UTXO");
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error("Expected a single iasset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single iasset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
   );
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error("Expected a single gov UTXO")
-  );
+  const govUtxo = await resolveUtxo(gov, lucid, "Expected a single gov UTXO");
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
   const priceOracleDatum = parsePriceOracleDatum(
     getInlineDatumOrThrow(priceOracleUtxo)
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "Expected a single interest oracle UTXO"
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
@@ -1767,13 +1782,7 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
   );
   const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
   if (interestTreasuryAdaAmt > 0) {
-    await treasuryFeeTx(
-      interestTreasuryAdaAmt,
-      lucid,
-      sysParams,
-      tx,
-      treasuryOref
-    );
+    await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
   }
   let collectorFee = interestCollectorAdaAmt;
   if (mintAmount > 0n) {
@@ -1789,75 +1798,75 @@ async function adjustCdp(collateralAmount, mintAmount, cdpOref, iassetOref, pric
     );
   }
   if (collectorFee > 0n) {
-    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collectorOref);
+    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collector);
   }
   return tx;
 }
-async function depositCdp(amount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, params, lucid, currentSlot) {
+async function depositCdp(amount, cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, params, lucid, currentSlot) {
   return adjustCdp(
     amount,
     0n,
-    cdpOref,
-    iassetOref,
-    priceOracleOref,
-    interestOracleOref,
-    collectorOref,
-    govOref,
-    treasuryOref,
+    cdp,
+    iasset,
+    priceOracle,
+    interestOracle,
+    collector,
+    gov,
+    treasury,
     params,
     lucid,
     currentSlot
   );
 }
-async function withdrawCdp(amount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, params, lucid, currentSlot) {
+async function withdrawCdp(amount, cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, params, lucid, currentSlot) {
   return adjustCdp(
     -amount,
     0n,
-    cdpOref,
-    iassetOref,
-    priceOracleOref,
-    interestOracleOref,
-    collectorOref,
-    govOref,
-    treasuryOref,
+    cdp,
+    iasset,
+    priceOracle,
+    interestOracle,
+    collector,
+    gov,
+    treasury,
     params,
     lucid,
     currentSlot
   );
 }
-async function mintCdp(amount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, params, lucid, currentSlot) {
+async function mintCdp(amount, cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, params, lucid, currentSlot) {
   return adjustCdp(
     0n,
     amount,
-    cdpOref,
-    iassetOref,
-    priceOracleOref,
-    interestOracleOref,
-    collectorOref,
-    govOref,
-    treasuryOref,
+    cdp,
+    iasset,
+    priceOracle,
+    interestOracle,
+    collector,
+    gov,
+    treasury,
     params,
     lucid,
     currentSlot
   );
 }
-async function burnCdp(amount, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, params, lucid, currentSlot) {
+async function burnCdp(amount, cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, params, lucid, currentSlot) {
   return adjustCdp(
     0n,
     -amount,
-    cdpOref,
-    iassetOref,
-    priceOracleOref,
-    interestOracleOref,
-    collectorOref,
-    govOref,
-    treasuryOref,
+    cdp,
+    iasset,
+    priceOracle,
+    interestOracle,
+    collector,
+    gov,
+    treasury,
     params,
     lucid,
     currentSlot
   );
 }
-async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, govOref, treasuryOref, sysParams, lucid, currentSlot) {
+async function closeCdp(cdp, iasset, priceOracle, interestOracle, collector, gov, treasury, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
@@ -1882,33 +1891,30 @@ async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref
     ]),
     (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
   );
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error("Expected a single cdp UTXO")
-  );
+  const cdpUtxo = await resolveUtxo(cdp, lucid, "Expected a single cdp UTXO");
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error("Expected a single iasset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single iasset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
   );
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error("Expected a single gov UTXO")
-  );
+  const govUtxo = await resolveUtxo(gov, lucid, "Expected a single gov UTXO");
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
   const priceOracleDatum = parsePriceOracleDatum(
     getInlineDatumOrThrow(priceOracleUtxo)
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "Expected a single interest oracle UTXO"
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
@@ -1961,24 +1967,18 @@ async function closeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref
   );
   const interestTreasuryAdaAmt = interestAdaAmt - interestCollectorAdaAmt;
   if (interestTreasuryAdaAmt > 0) {
-    await treasuryFeeTx(
-      interestTreasuryAdaAmt,
-      lucid,
-      sysParams,
-      tx,
-      treasuryOref
-    );
+    await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
   }
   const collectorFee = interestCollectorAdaAmt + calculateFeeFromPercentage(
     govDatum.protocolParams.collateralFeePercentage,
     lovelacesAmt(cdpUtxo.assets) - interestAdaAmt
   );
   if (collectorFee > 0n) {
-    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collectorOref);
+    await collectorFeeTx(collectorFee, lucid, sysParams, tx, collector);
   }
   return tx;
 }
-async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, priceOracleOref, interestOracleOref, collectorOref, treasuryOref, sysParams, lucid, currentSlot) {
+async function redeemCdp(attemptedRedemptionIAssetAmt, cdp, iasset, priceOracle, interestOracle, collector, treasury, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
@@ -1995,28 +1995,28 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
     ]),
     (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
   );
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error("Expected a single cdp UTXO")
-  );
+  const cdpUtxo = await resolveUtxo(cdp, lucid, "Expected a single cdp UTXO");
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error("Expected a single iasset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single iasset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
   );
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
   const priceOracleDatum = parsePriceOracleDatum(
     getInlineDatumOrThrow(priceOracleUtxo)
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "Expected a single interest oracle UTXO"
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
@@ -2120,18 +2120,12 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, pric
     lucid,
     sysParams,
     tx,
-    collectorOref
-  );
-  await treasuryFeeTx(
-    interestTreasuryAdaAmt,
-    lucid,
-    sysParams,
-    tx,
-    treasuryOref
+    collector
   );
+  await treasuryFeeTx(interestTreasuryAdaAmt, lucid, sysParams, tx, treasury);
   return tx;
 }
-async function freezeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOref, sysParams, lucid, currentSlot) {
+async function freezeCdp(cdp, iasset, priceOracle, interestOracle, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid18.slotToUnixTime)(network, currentSlot));
   const cdpRefScriptUtxo = matchSingle(
@@ -2140,28 +2134,28 @@ async function freezeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOre
     ]),
     (_) => new Error("Expected a single cdp Ref Script UTXO")
   );
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error("Expected a single cdp UTXO")
-  );
+  const cdpUtxo = await resolveUtxo(cdp, lucid, "Expected a single cdp UTXO");
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOref]),
-    (_) => new Error("Expected a single iasset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single iasset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
   );
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOref]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
   const priceOracleDatum = parsePriceOracleDatum(
     getInlineDatumOrThrow(priceOracleUtxo)
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "Expected a single interest oracle UTXO"
   );
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
@@ -2236,7 +2230,7 @@ async function freezeCdp(cdpOref, iassetOref, priceOracleOref, interestOracleOre
     cdpUtxo.assets
   );
 }
-async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryOref, sysParams, lucid) {
+async function liquidateCdp(cdp, stabilityPool, collector, treasury, sysParams, lucid) {
   const cdpRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(sysParams.scriptReferences.cdpValidatorRef)
@@ -2267,14 +2261,12 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
     ]),
     (_) => new Error("Expected a single cdp auth token policy Ref Script UTXO")
   );
-  const cdpUtxo = matchSingle(
-    await lucid.utxosByOutRef([cdpOref]),
-    (_) => new Error("Expected a single cdp UTXO")
-  );
+  const cdpUtxo = await resolveUtxo(cdp, lucid, "Expected a single cdp UTXO");
   const cdpDatum = parseCdpDatumOrThrow(getInlineDatumOrThrow(cdpUtxo));
-  const spUtxo = matchSingle(
-    await lucid.utxosByOutRef([stabilityPoolOref]),
-    (_) => new Error("Expected a single stability pool UTXO")
+  const spUtxo = await resolveUtxo(
+    stabilityPool,
+    lucid,
+    "Expected a single stability pool UTXO"
   );
   const spDatum = parseStabilityPoolDatum(getInlineDatumOrThrow(spUtxo));
   const [lovelacesForTreasury, lovelacesForCollector] = (0, import_ts_pattern7.match)(cdpDatum.cdpFees).returnType().with({ FrozenCDPAccumulatedFees: import_ts_pattern7.P.select() }, (fees) => [
@@ -2344,14 +2336,8 @@ async function liquidateCdp(cdpOref, stabilityPoolOref, collectorOref, treasuryO
       import_lucid18.Data.void()
     );
   }
-  await collectorFeeTx(
-    lovelacesForCollector,
-    lucid,
-    sysParams,
-    tx,
-    collectorOref
-  );
-  await treasuryFeeTx(lovelacesForTreasury, lucid, sysParams, tx, treasuryOref);
+  await collectorFeeTx(lovelacesForCollector, lucid, sysParams, tx, collector);
+  await treasuryFeeTx(lovelacesForTreasury, lucid, sysParams, tx, treasury);
   return tx;
 }
 async function mergeCdps(cdpsToMergeUtxos, sysParams, lucid) {
@@ -2858,20 +2844,17 @@ function updateStakingLockedAmount(stakingPosLockedAmt, currentTime) {
     stakingPosLockedAmt.entries().filter(([_, { votingEnd }]) => votingEnd > currentTime)
   );
 }
-function findStakingManagerByOutRef(stakingManagerRef, lucid) {
-  return lucid.utxosByOutRef([stakingManagerRef]).then(
-    (utxos) => utxos.map((utxo) => {
-      if (!utxo.datum) return void 0;
-      const datum = parseStakingManagerDatum(utxo.datum);
-      return { utxo, datum };
-    }).find((utxo) => utxo !== void 0)
-  ).then((result) => {
-    if (!result)
-      throw new Error(
-        "Unable to locate Staking Manager by output reference."
-      );
-    return result;
-  });
+async function findStakingManagerByOutRef(stakingManager, lucid) {
+  const utxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    "Unable to locate Staking Manager by output reference."
+  );
+  if (!utxo.datum) {
+    throw new Error("Staking Manager UTxO has no datum.");
+  }
+  const datum = parseStakingManagerDatum(utxo.datum);
+  return { utxo, datum };
 }
 function findStakingManager(params, lucid) {
   return lucid.utxosAtWithUnit(
@@ -2894,20 +2877,17 @@ function findStakingManager(params, lucid) {
     return result;
   });
 }
-function findStakingPositionByOutRef(stakingPositionRef, lucid) {
-  return lucid.utxosByOutRef([stakingPositionRef]).then(
-    (utxos) => utxos.map((utxo) => {
-      if (!utxo.datum) return void 0;
-      const datum = parseStakingPositionOrThrow(utxo.datum);
-      return { utxo, datum };
-    }).find((utxo) => utxo !== void 0)
-  ).then((result) => {
-    if (!result)
-      throw new Error(
-        "Unable to locate Staking Position by output reference."
-      );
-    return result;
-  });
+async function findStakingPositionByOutRef(stakingPosition, lucid) {
+  const utxo = await resolveUtxo(
+    stakingPosition,
+    lucid,
+    "Unable to locate Staking Position by output reference."
+  );
+  if (!utxo.datum) {
+    throw new Error("Staking Position UTxO has no datum.");
+  }
+  const datum = parseStakingPositionOrThrow(utxo.datum);
+  return { utxo, datum };
 }
 var rewardSnapshotPrecision = OCD_DECIMAL_UNIT * OCD_DECIMAL_UNIT;
 function distributeReward(snapshotAda, adaReward, totalStake) {
@@ -3019,89 +2999,38 @@ var teamVestingSchedule = [
   }
 ];
 var spDistributionSchedule = {
-  maxUnlockable: 14000000n * OCD_DECIMAL_UNIT,
+  maxUnlockable: 2013760n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1669931100000n,
       unlockAmt: 28768n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1701467100000n,
-      unlockAmt: 33562n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1727387100000n,
-      unlockAmt: 33561n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1733003100000n,
-      unlockAmt: 38356n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1764539100000n,
-      unlockAmt: 43150n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1796075100000n,
-      unlockAmt: 47945n * OCD_DECIMAL_UNIT
     }
   ]
 };
 var liqDistributionSchedule = {
-  maxUnlockable: 5250000n * OCD_DECIMAL_UNIT,
+  maxUnlockable: 316470n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1671659100000n,
       unlockAmt: 4795n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1703195100000n,
-      unlockAmt: 9590n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1728683100000n,
-      unlockAmt: 9589n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1734731100000n,
-      unlockAmt: 14383n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1766267100000n,
-      unlockAmt: 19178n * OCD_DECIMAL_UNIT
-    },
+    }
+  ]
+};
+var spLpDistributionSchedule = {
+  maxUnlockable: 17016441n * OCD_DECIMAL_UNIT,
+  schedule: [
     {
-      vestedAtTime: 1797803100000n,
-      unlockAmt: 23972n * OCD_DECIMAL_UNIT
+      vestedAtTime: 1700171100000n,
+      unlockAmt: 33563n * OCD_DECIMAL_UNIT
     }
   ]
 };
 var govDistributionSchedule = {
-  maxUnlockable: 1750000n * OCD_DECIMAL_UNIT,
+  maxUnlockable: 1381248n * OCD_DECIMAL_UNIT,
   schedule: [
     {
       vestedAtTime: 1670363100000n,
       unlockAmt: 2398n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1701899100000n,
-      unlockAmt: 3596n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1733435100000n,
-      unlockAmt: 4795n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1752443100000n,
-      unlockAmt: 4794n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1764971100000n,
-      unlockAmt: 5993n * OCD_DECIMAL_UNIT
-    },
-    {
-      vestedAtTime: 1796507100000n,
-      unlockAmt: 7191n * OCD_DECIMAL_UNIT
     }
   ]
 };
@@ -3134,7 +3063,7 @@ function calculateVestedPerEpoch(schedule, currentTime) {
   return bigintMin(schedule.maxUnlockable, go(schedule.schedule));
 }
 function calculateTotalVestedRewards(currentTime) {
-  return calculateVestedPerEpoch(spDistributionSchedule, currentTime) + calculateVestedPerEpoch(govDistributionSchedule, currentTime) + calculateVestedPerEpoch(liqDistributionSchedule, currentTime);
+  return calculateVestedPerEpoch(spDistributionSchedule, currentTime) + calculateVestedPerEpoch(govDistributionSchedule, currentTime) + calculateVestedPerEpoch(liqDistributionSchedule, currentTime) + calculateVestedPerEpoch(spLpDistributionSchedule, currentTime);
 }
 
 // src/contracts/poll/helpers.ts
@@ -3156,7 +3085,7 @@ function q(initialIndyDist, pollStatus, currentTime, treasuryIndyWithdrawnAmt) {
         )
       }
     ).getOnChainInt;
-    return { getOnChainInt: BigInt(q2) };
+    return { getOnChainInt: BigInt(q2) / 1000n };
   }
 }
 function pollPassQuorum(initialIndyDist, pollStatus, currentTime, minQuorum, treasuryIndyWithdrawnAmt) {
@@ -3332,7 +3261,7 @@ function serialiseVersionRecordDatum(d) {
 }
 
 // src/contracts/gov/transactions.ts
-async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, govOref, allIAssetOrefs) {
+async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lucid, currentSlot, gov, allIAssetOrefs) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
@@ -3353,10 +3282,7 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
     ]),
     (_) => 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 govUtxo = await resolveUtxo(gov, lucid, "Expected a single Gov UTXO");
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
   const votingEndTime = currentTime + govDatum.protocolParams.votingPeriod;
   const expirationTime = votingEndTime + govDatum.protocolParams.expirationPeriod;
@@ -3450,18 +3376,19 @@ async function createProposal(proposalContent, treasuryWithdrawal, sysParams, lu
     newPollId
   ];
 }
-async function createShardsChunks(chunkSize, pollManagerOref, sysParams, currentSlot, lucid) {
+async function createShardsChunks(chunkSize, pollManager, sysParams, currentSlot, lucid) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error("Expected a single Poll manager UTXO")
+  const pollManagerUtxo = await resolveUtxo(
+    pollManager,
+    lucid,
+    "Expected a single Poll manager UTXO"
   );
-  const pollManager = parsePollManagerOrThrow(
+  const pollManagerDatum = parsePollManagerOrThrow(
     getInlineDatumOrThrow(pollManagerUtxo)
   );
-  if (pollManager.createdShardsCount >= pollManager.totalShardsCount) {
+  if (pollManagerDatum.createdShardsCount >= pollManagerDatum.totalShardsCount) {
     throw new Error("All shards already created.");
   }
   const pollAuthTokenPolicyRefScriptUtxo = matchSingle(
@@ -3483,7 +3410,9 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
   const shardsCount = BigInt(
     Math.min(
       Number(chunkSize),
-      Number(pollManager.totalShardsCount - pollManager.createdShardsCount)
+      Number(
+        pollManagerDatum.totalShardsCount - pollManagerDatum.createdShardsCount
+      )
     )
   );
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
@@ -3499,8 +3428,8 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
       value: serialisePollDatum({
         PollManager: {
           content: {
-            ...pollManager,
-            createdShardsCount: pollManager.createdShardsCount + shardsCount
+            ...pollManagerDatum,
+            createdShardsCount: pollManagerDatum.createdShardsCount + shardsCount
           }
         }
       })
@@ -3515,9 +3444,9 @@ async function createShardsChunks(chunkSize, pollManagerOref, sysParams, current
         value: serialisePollDatum({
           PollShard: {
             content: {
-              pollId: pollManager.pollId,
+              pollId: pollManagerDatum.pollId,
               status: { yesVotes: 0n, noVotes: 0n },
-              votingEndTime: pollManager.votingEndTime,
+              votingEndTime: pollManagerDatum.votingEndTime,
               managerAddress: addressFromBech32(pollManagerUtxo.address)
             }
           }
@@ -3545,7 +3474,7 @@ function voteHelper(stakingPosLockedAmt, pollShard, voteOption, currentTime, ind
   ];
   return [new Map(newLockedAmt), newPollStatus];
 }
-async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, lucid, currentSlot) {
+async function vote(voteOption, pollShard, stakingPosition, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
@@ -3563,16 +3492,18 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     ]),
     (_) => new Error("Expected a single staking ref Script UTXO")
   );
-  const pollShardUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollShardOref]),
-    (_) => new Error("Expected a single Poll shard UTXO")
+  const pollShardUtxo = await resolveUtxo(
+    pollShard,
+    lucid,
+    "Expected a single Poll shard UTXO"
   );
   const pollShardDatum = parsePollShardOrThrow(
     getInlineDatumOrThrow(pollShardUtxo)
   );
-  const stakingPosUtxo = matchSingle(
-    await lucid.utxosByOutRef([stakingPositionOref]),
-    (_) => new Error("Expected a single staking position UTXO")
+  const stakingPosUtxo = await resolveUtxo(
+    stakingPosition,
+    lucid,
+    "Expected a single staking position UTXO"
   );
   const stakingPosDatum = parseStakingPositionOrThrow(
     getInlineDatumOrThrow(stakingPosUtxo)
@@ -3592,7 +3523,12 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     BigInt(validityFrom),
     indyStakedAmt
   );
-  return lucid.newTx().validFrom(validityFrom).validTo(Number(pollShardDatum.votingEndTime) - ONE_SECOND).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
+  return lucid.newTx().validFrom(validityFrom).validTo(
+    Math.min(
+      Number(pollShardDatum.votingEndTime) - ONE_SECOND,
+      Number(currentTime) + Number(sysParams.govParams.gBiasTime) - ONE_SECOND
+    )
+  ).readFrom([stakingRefScriptUtxo, pollShardRefScriptUtxo]).collectFrom([stakingPosUtxo], serialiseStakingRedeemer("Lock")).collectFrom(
     [pollShardUtxo],
     serialisePollShardRedeemer({ Vote: { content: voteOption } })
   ).pay.ToContract(
@@ -3621,7 +3557,7 @@ async function vote(voteOption, pollShardOref, stakingPositionOref, sysParams, l
     stakingPosUtxo.assets
   ).addSigner(ownAddr);
 }
-async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, currentSlot) {
+async function mergeShards(pollManager, shardsOutRefs, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
@@ -3649,9 +3585,10 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     ]),
     (_) => new Error("Expected a single poll auth token policy ref Script UTXO")
   );
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error("Expected a single Poll manager UTXO")
+  const pollManagerUtxo = await resolveUtxo(
+    pollManager,
+    lucid,
+    "Expected a single Poll manager UTXO"
   );
   const pollManagerDatum = parsePollManagerOrThrow(
     getInlineDatumOrThrow(pollManagerUtxo)
@@ -3712,7 +3649,7 @@ async function mergeShards(pollManagerOref, shardsOutRefs, sysParams, lucid, cur
     (0, import_lucid30.addAssets)(pollManagerUtxo.assets, shardsAggregatedAda)
   ).addSigner(ownAddr);
 }
-async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSlot) {
+async function endProposal(pollManager, gov, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
@@ -3748,28 +3685,26 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
     ]),
     (_) => new Error("Expected a single upgrade auth token policy ref Script UTXO")
   );
-  const pollManagerUtxo = matchSingle(
-    await lucid.utxosByOutRef([pollManagerOref]),
-    (_) => new Error("Expected a single Poll manager UTXO")
+  const pollManagerUtxo = await resolveUtxo(
+    pollManager,
+    lucid,
+    "Expected a single Poll manager UTXO"
   );
-  const pollManager = parsePollManagerOrThrow(
+  const pollManagerDatum = parsePollManagerOrThrow(
     getInlineDatumOrThrow(pollManagerUtxo)
   );
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error("Expected a single Gov UTXO")
-  );
+  const govUtxo = await resolveUtxo(gov, lucid, "Expected a single Gov UTXO");
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
   const pollNft = fromSystemParamsAsset(sysParams.govParams.pollToken);
   const indyAsset = fromSystemParamsAsset(
     sysParams.pollManagerParams.indyAsset
   );
-  const proposalExpired = currentTime > pollManager.expirationTime;
+  const proposalExpired = currentTime > pollManagerDatum.expirationTime;
   const proposalPassed = !proposalExpired && pollPassQuorum(
     sysParams.pollManagerParams.initialIndyDistribution,
-    pollManager.status,
+    pollManagerDatum.status,
     currentTime,
-    pollManager.minimumQuorum,
+    pollManagerDatum.minimumQuorum,
     govDatum.treasuryIndyWithdrawnAmt
   );
   const upgradeTokenVal = mkAssetsOf(
@@ -3806,12 +3741,12 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
       {
         kind: "inline",
         value: serialiseExecuteDatum({
-          id: pollManager.pollId,
-          content: pollManager.content,
+          id: pollManagerDatum.pollId,
+          content: pollManagerDatum.content,
           passedTime: currentTime,
-          votingEndTime: pollManager.votingEndTime,
-          protocolVersion: pollManager.protocolVersion,
-          treasuryWithdrawal: pollManager.treasuryWithdrawal
+          votingEndTime: pollManagerDatum.votingEndTime,
+          protocolVersion: pollManagerDatum.protocolVersion,
+          treasuryWithdrawal: pollManagerDatum.treasuryWithdrawal
         })
       },
       upgradeTokenVal
@@ -3828,14 +3763,11 @@ async function endProposal(pollManagerOref, govOref, sysParams, lucid, currentSl
   }
   return tx;
 }
-async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, allIAssetOrefs, modifyIAssetOref, sysParams, lucid, currentSlot) {
+async function executeProposal(execute, gov, treasuryWithdrawal, allIAssetOrefs, modifyIAsset, sysParams, lucid, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid30.slotToUnixTime)(network, currentSlot));
   const ownAddr = await lucid.wallet().address();
-  const govUtxo = matchSingle(
-    await lucid.utxosByOutRef([govOref]),
-    (_) => new Error("Expected a single gov UTXO")
-  );
+  const govUtxo = await resolveUtxo(gov, lucid, "Expected a single gov UTXO");
   const govDatum = parseGovDatumOrThrow(getInlineDatumOrThrow(govUtxo));
   const govRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -3859,9 +3791,10 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     ]),
     (_) => new Error("Expected a single upgrade auth token policy ref Script UTXO")
   );
-  const executeUtxo = matchSingle(
-    await lucid.utxosByOutRef([executeOref]),
-    (_) => new Error("Expected a single execute UTXO")
+  const executeUtxo = await resolveUtxo(
+    execute,
+    lucid,
+    "Expected a single execute UTXO"
   );
   const executeDatum = parseExecuteDatumOrThrow(
     getInlineDatumOrThrow(executeUtxo)
@@ -3879,13 +3812,13 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
     import_fp_ts10.option.fromNullable(executeDatum.treasuryWithdrawal),
     import_fp_ts10.option.match(
       () => {
-        if (treasuryWithdrawalOref) {
+        if (treasuryWithdrawal) {
           throw new Error("Cannot provide withdrawal oref when no withdrawal.");
         }
         return Promise.resolve();
       },
       async (withdrawal) => {
-        if (!treasuryWithdrawalOref) {
+        if (!treasuryWithdrawal) {
           throw new Error("Have to provide withdrawal oref when withdrawal.");
         }
         const treasuryRefScriptUtxo = matchSingle(
@@ -3896,9 +3829,10 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
           ]),
           (_) => new Error("Expected a single Treasury Ref Script UTXO")
         );
-        const treasuryWithdrawalUtxo = matchSingle(
-          await lucid.utxosByOutRef([treasuryWithdrawalOref]),
-          (_) => new Error("Expected a single withdrawal UTXO")
+        const treasuryWithdrawalUtxo = await resolveUtxo(
+          treasuryWithdrawal,
+          lucid,
+          "Expected a single withdrawal UTXO"
         );
         const withdrawalVal = createValueFromWithdrawal(withdrawal);
         const withdrawalChangeVal = (0, import_lucid30.addAssets)(
@@ -4061,12 +3995,13 @@ async function executeProposal(executeOref, govOref, treasuryWithdrawalOref, all
       ]),
       (_) => new Error("Expected a single CDP Ref Script UTXO")
     );
-    if (!modifyIAssetOref) {
+    if (!modifyIAsset) {
       throw new Error("Have to provide iasset oref when modify asset.");
     }
-    const iassetUtxo = matchSingle(
-      await lucid.utxosByOutRef([modifyIAssetOref]),
-      (_) => new Error("Expected a single iasset UTXO")
+    const iassetUtxo = await resolveUtxo(
+      modifyIAsset,
+      lucid,
+      "Expected a single iasset UTXO"
     );
     const iassetDatum = parseIAssetDatumOrThrow(
       getInlineDatumOrThrow(iassetUtxo)
@@ -4395,7 +4330,7 @@ async function closeSpAccount(accountUtxo, params, lucid) {
     }
   ).addSignerKey((0, import_lucid34.toHex)(oldAccountDatum.owner));
 }
-async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo, iAssetUtxo, newSnapshotUtxo, params, lucid, collectorOref) {
+async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo, iAssetUtxo, newSnapshotUtxo, params, lucid, collector) {
   const redeemer = {
     ProcessRequest: {
       txHash: { hash: (0, import_lucid34.fromHex)(accountUtxo.txHash) },
@@ -4578,13 +4513,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       newPoolSum
     );
     if (rewardLovelacesFee > 0n) {
-      await collectorFeeTx(
-        rewardLovelacesFee,
-        lucid,
-        params,
-        tx,
-        collectorOref
-      );
+      await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collector);
     }
     tx.readFrom([govUtxo, iAssetUtxo, ...refInputs]);
     tx.pay.ToContract(
@@ -4695,7 +4624,7 @@ async function processSpRequest(asset, stabilityPoolUtxo, accountUtxo, govUtxo,
       params.scriptReferences.authTokenPolicies.accountTokenRef,
       lucid
     );
-    await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collectorOref);
+    await collectorFeeTx(rewardLovelacesFee, lucid, params, tx, collector);
     tx.readFrom([govUtxo, iAssetUtxo, accountTokenRef, ...refInputs]);
     tx.mintAssets(
       {
@@ -4786,9 +4715,16 @@ async function annulRequest(accountUtxo, params, lucid) {
 
 // src/contracts/staking/transactions.ts
 var import_lucid35 = require("@lucid-evolution/lucid");
-async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
+async function openStakingPosition(amount, params, lucid, stakingManager) {
   const [pkh, _] = await addrDetails(lucid);
-  const stakingManagerOut = stakingManagerRef ? await findStakingManagerByOutRef(stakingManagerRef, lucid) : await findStakingManager(params, lucid);
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    "Expected a single staking manager UTXO"
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo)
+  );
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef)
@@ -4804,39 +4740,39 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     (_2) => new Error("Expected a single staking token policy Ref Script UTXO")
   );
   const newStakingManagerDatum = {
-    totalStake: stakingManagerOut.datum.totalStake + amount,
+    totalStake: stakingManagerDatum.totalStake + amount,
     managerSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda
+      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda
     }
   };
   const stakingPositionDatum = {
     owner: (0, import_lucid35.fromHex)(pkh.hash),
     lockedAmount: /* @__PURE__ */ new Map([]),
     positionSnapshot: {
-      snapshotAda: stakingManagerOut.datum.managerSnapshot.snapshotAda
+      snapshotAda: stakingManagerDatum.managerSnapshot.snapshotAda
     }
   };
   const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingToken[1].unTokenName);
   const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
   return lucid.newTx().collectFrom(
-    [stakingManagerOut.utxo],
+    [stakingManagerUtxo],
     serialiseStakingRedeemer({
       CreateStakingPosition: { creatorPkh: pkh.hash }
     })
   ).readFrom([stakingRefScriptUtxo]).pay.ToContract(
-    stakingManagerOut.utxo.address,
+    stakingManagerUtxo.address,
     {
       kind: "inline",
       value: serialiseStakingDatum(newStakingManagerDatum)
     },
-    stakingManagerOut.utxo.assets
+    stakingManagerUtxo.assets
   ).readFrom([stakingTokenPolicyRefScriptUtxo]).mintAssets(
     {
       [stakingToken]: 1n
     },
     import_lucid35.Data.void()
   ).pay.ToContract(
-    stakingManagerOut.utxo.address,
+    stakingManagerUtxo.address,
     {
       kind: "inline",
       value: serialiseStakingDatum(stakingPositionDatum)
@@ -4847,14 +4783,25 @@ async function openStakingPosition(amount, params, lucid, stakingManagerRef) {
     }
   ).addSignerKey(pkh.hash);
 }
-async function adjustStakingPosition(stakingPositionRef, amount, params, lucid, currentSlot, stakingManagerRef) {
+async function adjustStakingPosition(stakingPosition, amount, params, lucid, currentSlot, stakingManager) {
   const network = lucid.config().network;
   const currentTime = (0, import_lucid35.slotToUnixTime)(network, currentSlot) - 120 * ONE_SECOND;
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
-    lucid
+  const stakingPositionUtxo = await resolveUtxo(
+    stakingPosition,
+    lucid,
+    "Expected a single staking position UTXO"
+  );
+  const stakingPositionDatum = parseStakingPositionOrThrow(
+    getInlineDatumOrThrow(stakingPositionUtxo)
+  );
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    "Expected a single staking manager UTXO"
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo)
   );
-  const stakingManagerOut = stakingManagerRef ? await findStakingManagerByOutRef(stakingManagerRef, lucid) : await findStakingManager(params, lucid);
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef)
@@ -4862,44 +4809,44 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
     (_) => new Error("Expected a single staking Ref Script UTXO")
   );
   const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
-  const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda = stakingManagerOut.datum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
+  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
+  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
+  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
   const adaReward = (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / rewardSnapshotPrecision;
   const newLockedAmount = updateStakingLockedAmount(
-    stakingPositionOut.datum.lockedAmount,
+    stakingPositionDatum.lockedAmount,
     BigInt(currentTime)
   );
   return lucid.newTx().validFrom(currentTime).readFrom([stakingRefScriptUtxo]).collectFrom(
-    [stakingPositionOut.utxo],
+    [stakingPositionUtxo],
     serialiseStakingRedeemer({
       AdjustStakedAmount: { adjustAmount: amount }
     })
   ).collectFrom(
-    [stakingManagerOut.utxo],
+    [stakingManagerUtxo],
     serialiseStakingRedeemer("UpdateTotalStake")
   ).pay.ToContract(
-    stakingManagerOut.utxo.address,
+    stakingManagerUtxo.address,
     {
       kind: "inline",
       value: serialiseStakingDatum({
-        ...stakingManagerOut.datum,
-        totalStake: stakingManagerOut.datum.totalStake + amount
+        ...stakingManagerDatum,
+        totalStake: stakingManagerDatum.totalStake + amount
       })
     },
-    (0, import_lucid35.addAssets)(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward))
+    (0, import_lucid35.addAssets)(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward))
   ).pay.ToContract(
-    stakingPositionOut.utxo.address,
+    stakingPositionUtxo.address,
     {
       kind: "inline",
       value: serialiseStakingDatum({
-        ...stakingPositionOut.datum,
+        ...stakingPositionDatum,
         lockedAmount: newLockedAmount,
-        positionSnapshot: stakingManagerOut.datum.managerSnapshot
+        positionSnapshot: stakingManagerDatum.managerSnapshot
       })
     },
     (0, import_lucid35.addAssets)(
-      stakingPositionOut.utxo.assets,
+      stakingPositionUtxo.assets,
       mkAssetsOf(
         {
           currencySymbol: params.stakingParams.indyToken[0].unCurrencySymbol,
@@ -4908,16 +4855,27 @@ async function adjustStakingPosition(stakingPositionRef, amount, params, lucid,
         amount
       )
     )
-  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionOut.datum.owner));
+  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionDatum.owner));
 }
-async function closeStakingPosition(stakingPositionRef, params, lucid, currentSlot, stakingManagerRef) {
+async function closeStakingPosition(stakingPosition, params, lucid, currentSlot, stakingManager) {
   const network = lucid.config().network;
   const currentTime = (0, import_lucid35.slotToUnixTime)(network, currentSlot) - ONE_SECOND;
-  const stakingPositionOut = await findStakingPositionByOutRef(
-    stakingPositionRef,
-    lucid
+  const stakingPositionUtxo = await resolveUtxo(
+    stakingPosition,
+    lucid,
+    "Expected a single staking position UTXO"
+  );
+  const stakingPositionDatum = parseStakingPositionOrThrow(
+    getInlineDatumOrThrow(stakingPositionUtxo)
+  );
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    "Expected a single staking manager UTXO"
+  );
+  const stakingManagerDatum = parseStakingManagerDatum(
+    getInlineDatumOrThrow(stakingManagerUtxo)
   );
-  const stakingManagerOut = stakingManagerRef ? await findStakingManagerByOutRef(stakingManagerRef, lucid) : await findStakingManager(params, lucid);
   const stakingRefScriptUtxo = matchSingle(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(params.scriptReferences.stakingValidatorRef)
@@ -4934,33 +4892,37 @@ async function closeStakingPosition(stakingPositionRef, params, lucid, currentSl
   );
   const stakingToken = params.stakingParams.stakingToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.stakingToken[1].unTokenName);
   const indyToken = params.stakingParams.indyToken[0].unCurrencySymbol + (0, import_lucid35.fromText)(params.stakingParams.indyToken[1].unTokenName);
-  const existingIndyAmount = stakingPositionOut.utxo.assets[indyToken] ?? 0n;
-  const currentSnapshotAda = stakingManagerOut.datum.managerSnapshot.snapshotAda;
-  const oldSnapshotAda = stakingPositionOut.datum.positionSnapshot.snapshotAda;
+  const existingIndyAmount = stakingPositionUtxo.assets[indyToken] ?? 0n;
+  const currentSnapshotAda = stakingManagerDatum.managerSnapshot.snapshotAda;
+  const oldSnapshotAda = stakingPositionDatum.positionSnapshot.snapshotAda;
   const adaReward = (currentSnapshotAda - oldSnapshotAda) * existingIndyAmount / (1000000n * 1000000n);
-  return lucid.newTx().validFrom(currentTime).readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo]).collectFrom([stakingPositionOut.utxo], serialiseStakingRedeemer("Unstake")).collectFrom(
-    [stakingManagerOut.utxo],
+  return lucid.newTx().validFrom(currentTime).readFrom([stakingRefScriptUtxo, stakingTokenPolicyRefScriptUtxo]).collectFrom([stakingPositionUtxo], serialiseStakingRedeemer("Unstake")).collectFrom(
+    [stakingManagerUtxo],
     serialiseStakingRedeemer("UpdateTotalStake")
   ).pay.ToContract(
-    stakingManagerOut.utxo.address,
+    stakingManagerUtxo.address,
     {
       kind: "inline",
       value: serialiseStakingDatum({
-        ...stakingManagerOut.datum,
-        totalStake: stakingManagerOut.datum.totalStake - existingIndyAmount
+        ...stakingManagerDatum,
+        totalStake: stakingManagerDatum.totalStake - existingIndyAmount
       })
     },
-    (0, import_lucid35.addAssets)(stakingManagerOut.utxo.assets, mkLovelacesOf(-adaReward))
+    (0, import_lucid35.addAssets)(stakingManagerUtxo.assets, mkLovelacesOf(-adaReward))
   ).mintAssets(
     {
       [stakingToken]: -1n
     },
     import_lucid35.Data.void()
-  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionOut.datum.owner));
+  ).addSignerKey((0, import_lucid35.toHex)(stakingPositionDatum.owner));
 }
 var MIN_UTXO_AMOUNT = 2000000n;
-async function distributeAda(stakingManagerRef, collectorRefs, params, lucid) {
-  const [stakingManagerUtxo] = await lucid.utxosByOutRef([stakingManagerRef]);
+async function distributeAda(stakingManager, collectorRefs, params, lucid) {
+  const stakingManagerUtxo = await resolveUtxo(
+    stakingManager,
+    lucid,
+    "Expected a single staking manager UTXO"
+  );
   const stakingManagerDatum = parseStakingManagerDatum(
     getInlineDatumOrThrow(stakingManagerUtxo)
   );
@@ -5118,16 +5080,16 @@ async function findInterestOracle(lucid, interestNft) {
 }
 
 // src/contracts/interest-oracle/transactions.ts
-async function startInterestOracle(initialUnitaryInterest, initialInterestRate, initialLastInterestUpdate, oracleParams, lucid, interestTokenName, withScriptRef = false, refOutRef) {
+async function startInterestOracle(initialUnitaryInterest, initialInterestRate, initialLastInterestUpdate, oracleParams, lucid, interestTokenName, withScriptRef = false, refUtxo) {
   const network = lucid.config().network;
   const tokenName = interestTokenName ?? "INTEREST_ORACLE";
-  if (!refOutRef) {
-    refOutRef = (await lucid.wallet().getUtxos())[0];
+  if (!refUtxo) {
+    refUtxo = (await lucid.wallet().getUtxos())[0];
   }
   const [tx, policyId] = await oneShotMintTx(lucid, {
     referenceOutRef: {
-      txHash: refOutRef.txHash,
-      outputIdx: BigInt(refOutRef.outputIndex)
+      txHash: refUtxo.txHash,
+      outputIdx: BigInt(refUtxo.outputIndex)
     },
     mintAmounts: [
       {
@@ -5691,21 +5653,18 @@ async function openLrp(assetTokenName, lovelacesAmt2, maxPrice, lucid, sysParams
     { lovelace: lovelacesAmt2 + MIN_LRP_COLLATERAL_AMT }
   );
 }
-async function cancelLrp(lrpOutRef, sysParams, lucid) {
+async function cancelLrp(lrp, sysParams, lucid) {
   const lrpScriptRefUtxo = matchSingle(
     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 lrpUtxo = await resolveUtxo(lrp, lucid, "Expected a single LRP UTXO.");
   const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
   return lucid.newTx().readFrom([lrpScriptRefUtxo]).collectFrom([lrpUtxo], serialiseLrpRedeemer("Cancel")).addSignerKey(lrpDatum.owner);
 }
-async function redeemLrp(redemptionLrpsData, priceOracleOutRef, iassetOutRef, lucid, sysParams) {
+async function redeemLrp(redemptionLrpsData, priceOracle, iasset, lucid, sysParams) {
   const network = lucid.config().network;
   const lrpScriptRefUtxo = matchSingle(
     await lucid.utxosByOutRef([
@@ -5713,13 +5672,15 @@ async function redeemLrp(redemptionLrpsData, priceOracleOutRef, iassetOutRef, lu
     ]),
     (_) => new Error("Expected a single LRP Ref Script UTXO")
   );
-  const priceOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([priceOracleOutRef]),
-    (_) => new Error("Expected a single price oracle UTXO")
+  const priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "Expected a single price oracle UTXO"
   );
-  const iassetUtxo = matchSingle(
-    await lucid.utxosByOutRef([iassetOutRef]),
-    (_) => new Error("Expected a single IAsset UTXO")
+  const iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single IAsset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
@@ -5744,17 +5705,14 @@ async function redeemLrp(redemptionLrpsData, priceOracleOutRef, iassetOutRef, lu
     )
   ).readFrom([lrpScriptRefUtxo]).readFrom([iassetUtxo, priceOracleUtxo]).compose(tx);
 }
-async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, newMaxPrice, sysParams) {
+async function adjustLrp(lucid, lrp, lovelacesAdjustAmt, newMaxPrice, sysParams) {
   const lrpScriptRefUtxo = matchSingle(
     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 lrpUtxo = await resolveUtxo(lrp, lucid, "Expected a single LRP UTXO.");
   const lrpDatum = parseLrpDatumOrThrow(getInlineDatumOrThrow(lrpUtxo));
   const rewardAssetClass = {
     currencySymbol: sysParams.lrpParams.iassetPolicyId.unCurrencySymbol,
@@ -5791,8 +5749,8 @@ async function adjustLrp(lucid, lrpOutRef, lovelacesAdjustAmt, newMaxPrice, sysP
     )
   ).addSignerKey(lrpDatum.owner);
 }
-async function claimLrp(lucid, lrpOutRef, sysParams) {
-  return adjustLrp(lucid, lrpOutRef, 0n, void 0, sysParams);
+async function claimLrp(lucid, lrp, sysParams) {
+  return adjustLrp(lucid, lrp, 0n, void 0, sysParams);
 }
 
 // src/contracts/lrp/scripts.ts
@@ -6019,7 +5977,7 @@ function calculateLeverageFromCollateralRatio(iasset, collateralRatioPercentage,
 }
 
 // src/contracts/leverage/transactions.ts
-async function leverageCdpWithLrp(leverage, baseCollateral, priceOracleOutRef, iassetOutRef, cdpCreatorOref, interestOracleOref, collectorOref, sysParams, lucid, allLrps, currentSlot) {
+async function leverageCdpWithLrp(leverage, baseCollateral, priceOracle, iasset, cdpCreator, interestOracle, collector, sysParams, lucid, allLrps, currentSlot) {
   const network = lucid.config().network;
   const currentTime = BigInt((0, import_lucid51.slotToUnixTime)(network, currentSlot));
   const [pkh, skh] = await addrDetails(lucid);
@@ -6053,27 +6011,31 @@ async function leverageCdpWithLrp(leverage, baseCollateral, priceOracleOutRef, i
     ]),
     (_) => 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 cdpCreatorUtxo = await resolveUtxo(
+    cdpCreator,
+    lucid,
+    "Expected a single CDP creator UTXO"
   );
-  const interestOracleUtxo = matchSingle(
-    await lucid.utxosByOutRef([interestOracleOref]),
-    (_) => new Error("Expected a single interest oracle UTXO")
+  const interestOracleUtxo = await resolveUtxo(
+    interestOracle,
+    lucid,
+    "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 priceOracleUtxo = await resolveUtxo(
+    priceOracle,
+    lucid,
+    "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 iassetUtxo = await resolveUtxo(
+    iasset,
+    lucid,
+    "Expected a single IAsset UTXO"
   );
   const iassetDatum = parseIAssetDatumOrThrow(
     getInlineDatumOrThrow(iassetUtxo)
@@ -6194,7 +6156,7 @@ async function leverageCdpWithLrp(leverage, baseCollateral, priceOracleOutRef, i
     2n
   );
   if (debtMintingFee > 0) {
-    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collectorOref);
+    await collectorFeeTx(debtMintingFee, lucid, sysParams, tx, collector);
   }
   return tx;
 }
@@ -6378,6 +6340,7 @@ async function leverageCdpWithLrp(leverage, baseCollateral, priceOracleOutRef, i
   randomLrpsSubsetSatisfyingTargetLovelaces,
   redeemCdp,
   redeemLrp,
+  resolveUtxo,
   rewardSnapshotPrecision,
   runCreateScriptRefTx,
   runOneShotMintTx,