@indigo-labs/indigo-sdk 0.5.16 → 0.6.1

package/dist/index.js

@@ -211,7 +211,6 @@ __export(index_exports, {
   initGovernance: () => initGovernance,
   initInterestCollector: () => initInterestCollector,
   initPythConfig: () => initPythConfig,
-  initScriptRef: () => initScriptRef,
   initSpState: () => initSpState,
   initStakingManager: () => initStakingManager,
   initSumVal: () => initSumVal,
@@ -348,6 +347,7 @@ __export(index_exports, {
   robCollateralAmtToSpend: () => robCollateralAmtToSpend,
   robIAssetAmtToSpend: () => robIAssetAmtToSpend,
   robSellOrderFilledAssets: () => robSellOrderFilledAssets,
+  runAndAwaitTxBuilder: () => runAndAwaitTxBuilder,
   runCreateScriptRefTx: () => runCreateScriptRefTx,
   runOneShotMintTx: () => runOneShotMintTx,
   scriptRef: () => scriptRef,
@@ -393,13 +393,13 @@ __export(index_exports, {
   spZeroNegatives: () => spZeroNegatives,
   startInterestOracle: () => startInterestOracle,
   startPriceOracleTx: () => startPriceOracleTx,
-  submitTx: () => submitTx,
   sum: () => sum,
   summariseOrder: () => summariseOrder,
   summarizeActualLeverageRedemptions: () => summarizeActualLeverageRedemptions,
   toAssetClassFromLucid: () => toAssetClassFromLucid,
   toDataDerivedPythPrice: () => toDataDerivedPythPrice,
   toSystemParamsAsset: () => toSystemParamsAsset,
+  toSystemParamsInput: () => toSystemParamsInput,
   treasuryCollect: () => treasuryCollect,
   treasuryFeeTx: () => treasuryFeeTx,
   treasuryMerge: () => treasuryMerge,
@@ -682,6 +682,12 @@ function getPythFeedConfig(cfg, iasset, collateralAsset) {
     throw new Error("No Pyth config known for such assets combination");
   return res;
 }
+function toSystemParamsInput(outRef) {
+  return {
+    transactionId: outRef.txHash,
+    index: outRef.outputIndex
+  };
+}
 function toSystemParamsAsset(asset) {
   return [
     { unCurrencySymbol: (0, import_lucid.toHex)(asset.currencySymbol) },
@@ -758,9 +764,26 @@ async function scriptRef(ref, lucid) {
   if (utxos.length === 0) throw Error("Unable to locate script ref.");
   return utxos[0];
 }
-async function submitTx(lucid, tx) {
-  const txHash = await tx.complete().then((t) => t.sign.withWallet().complete()).then((t) => t.submit());
+var defaultSubmissionConfig = {
+  extraSigners: [],
+  useLocalOverride: true
+};
+async function runAndAwaitTxBuilder(lucid, transaction, submissionConfig) {
+  const config = {
+    ...defaultSubmissionConfig,
+    ...submissionConfig
+  };
+  const [newWalletUTxOs, _, bTx] = await transaction.chain();
+  const signatures = [await bTx.partialSign.withWallet()];
+  for (const signer of config.extraSigners) {
+    lucid.selectWallet.fromSeed(signer);
+    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
+  }
+  const signedTx = bTx.assemble(signatures);
+  const txHash = await signedTx.complete().then((tx) => tx.submit());
   await lucid.awaitTx(txHash);
+  lucid.overrideUTxOs(newWalletUTxOs);
+  return txHash;
 }
 function balance(utxos) {
   return utxos.reduce((acc, utxo) => (0, import_lucid2.addAssets)(acc, utxo.assets), {});
@@ -837,8 +860,9 @@ function calculateAccruedInterest(now, unitaryInterestSnapshot, mintedAmount, in
 
 // src/contracts/price-oracle/helpers.ts
 function oracleExpirationAwareValidity(lucid, biasTime, oracleExpiration) {
-  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-  const defaultValidateTo = validateFrom + biasTime;
+  const currentTime = lucid.slotToUnixTime(lucid.currentSlot());
+  const validateFrom = currentTime - Math.floor(biasTime / 2);
+  const defaultValidateTo = currentTime + Math.floor(biasTime / 2);
   const cappedValidateTo = lucid.slotToUnixTime(
     lucid.unixTimeToSlot(oracleExpiration) - 1
   );
@@ -893,7 +917,15 @@ function computeEffectiveCdpState(now, cdpUtxoAssets, cdpContent, interestOracle
     collateralAmt
   };
 }
-function cdpCollateralRatioPercentage(now, iassetPrice, cdpUtxoAssets, cdpContent, interestOracleDatum) {
+var defaultLoanAdjustments = {
+  collateralAdjustment: 0n,
+  debtAdjustment: 0n
+};
+function cdpCollateralRatioPercentage(now, iassetPrice, cdpUtxoAssets, cdpContent, interestOracleDatum, loanAdjustments) {
+  const adjustments = {
+    ...defaultLoanAdjustments,
+    ...loanAdjustments
+  };
   const cdpState = computeEffectiveCdpState(
     now,
     cdpUtxoAssets,
@@ -901,8 +933,11 @@ function cdpCollateralRatioPercentage(now, iassetPrice, cdpUtxoAssets, cdpConten
     interestOracleDatum
   );
   const ratio = rationalDiv(
-    rationalFromInt(cdpState.collateralAmt),
-    rationalMul(rationalFromInt(cdpState.mintedAmt), iassetPrice)
+    rationalFromInt(cdpState.collateralAmt + adjustments.collateralAdjustment),
+    rationalMul(
+      rationalFromInt(cdpState.mintedAmt + adjustments.debtAdjustment),
+      iassetPrice
+    )
   );
   return Number(ratio.numerator) * 100 / Number(ratio.denominator);
 }
@@ -2566,8 +2601,12 @@ async function batchCollectInterest(collateralAssetOref, interestCollectorOutRef
     referenceInputs,
     false
   );
-  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-  const validateTo = validateFrom + Number(params.cdpParams.biasTime);
+  const validateFrom = Number(
+    currentTime - BigInt(params.cdpParams.biasTime) / 2n
+  );
+  const validateTo = Number(
+    currentTime + BigInt(params.cdpParams.biasTime) / 2n
+  );
   const tx = lucid.newTx().validFrom(validateFrom).validTo(validateTo).readFrom(referenceInputs).collectFrom([interestCollectorUtxo], {
     kind: "selected",
     makeRedeemer: (inputIndices) => {
@@ -4073,6 +4112,8 @@ function derivePythPrice(derivedPythPrice, messageHex) {
 
 // src/contracts/iasset/helpers.ts
 var Core = __toESM(require("@evolution-sdk/evolution"));
+var MAX_PYTH_FEED_DELAY = 280 * 1e3;
+var PYTH_FEED_LEDGER_TIME_BUFFER = 20 * 1e3;
 var MAX_COLLATERAL_ASSETS_COUNT_PER_IASSET = 9;
 function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythStateOref, pythMessage, pythConfig, biasTime, lucid, tx) {
   return (0, import_ts_pattern12.match)(priceInfo).returnType().with({ Delisted: import_ts_pattern12.P.any }, () => {
@@ -4153,9 +4194,8 @@ function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythS
           auxiliaryData: Core.Data.fromCBORHex(import_lucid11.Data.void())
         })
       );
-      const pythMaxDelay = 280 * 1e3;
-      const validFrom = Number(pythTimestamp);
-      const validTo = Number(pythTimestamp + pythMaxDelay);
+      const validFrom = Number(pythTimestamp - PYTH_FEED_LEDGER_TIME_BUFFER);
+      const validTo = Number(pythTimestamp + MAX_PYTH_FEED_DELAY);
       return {
         interval: {
           validFrom,
@@ -4639,8 +4679,12 @@ async function closeCdp(cdpOref, collateralAssetOref, interestOracleOref, intere
   const interestOracleDatum = parseInterestOracleDatum(
     getInlineDatumOrThrow(interestOracleUtxo)
   );
-  const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-  const validateTo = validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
+  const validateFrom = Number(
+    currentTime - BigInt(sysParams.cdpParams.biasTime) / 2n
+  );
+  const validateTo = Number(
+    currentTime + BigInt(sysParams.cdpParams.biasTime) / 2n
+  );
   const tx = lucid.newTx().readFrom([
     cdpRefScriptUtxo,
     iAssetTokenPolicyRefScriptUtxo,
@@ -4835,8 +4879,12 @@ async function redeemCdp(attemptedRedemptionIAssetAmt, cdpOref, iassetOref, coll
     referenceInputs.push(priceOracleUtxo);
     tx.validFrom(txValidity.validFrom).validTo(txValidity.validTo);
   } else {
-    const validateFrom = lucid.slotToUnixTime(lucid.currentSlot() - 1);
-    const validateTo = validateFrom + Number(sysParams.cdpCreatorParams.biasTime);
+    const validateFrom = Number(
+      currentTime - BigInt(sysParams.cdpParams.biasTime) / 2n
+    );
+    const validateTo = Number(
+      currentTime + BigInt(sysParams.cdpParams.biasTime) / 2n
+    );
     tx.validFrom(validateFrom).validTo(validateTo);
   }
   const partialRedemptionFee = import_fp_ts13.function.pipe(
@@ -7595,10 +7643,9 @@ async function oneShotMintTx(lucid, params) {
     policyId
   ];
 }
-async function runOneShotMintTx(lucid, params) {
+async function runOneShotMintTx(lucid, params, submissionConfig) {
   const [tx, policyId] = await oneShotMintTx(lucid, params);
-  const txHash = await tx.complete().then((tx2) => tx2.sign.withWallet().complete()).then((tx2) => tx2.submit());
-  await lucid.awaitTx(txHash);
+  await runAndAwaitTxBuilder(lucid, tx, submissionConfig);
   return policyId;
 }
 
@@ -8344,9 +8391,8 @@ async function requestSpAccountClosure(accountUtxo, sysParams, lucid, maxTxFee =
     )
   ).addSignerKey((0, import_lucid47.toHex)(oldAccountDatum.owner));
 }
-async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, txFee, currentSlot) {
-  const slot = currentSlot !== void 0 ? currentSlot : lucid.currentSlot();
-  const currentTime = BigInt(lucid.slotToUnixTime(slot));
+async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, txFee) {
+  const currentTime = BigInt(lucid.slotToUnixTime(lucid.currentSlot()));
   const stabilityPoolScriptRef = (0, import_cardano_offchain_common24.matchSingle)(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -8362,8 +8408,13 @@ async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetU
     getInlineDatumOrThrow(stabilityPoolUtxo)
   );
   const baseRefInputs = [iAssetUtxo, stabilityPoolScriptRef];
-  const validFrom = lucid.slotToUnixTime(slot - 1);
-  const tx = lucid.newTx().validFrom(validFrom).validTo(validFrom + sysParams.stabilityPoolParams.accountProcessingBiasMs).readFrom(baseRefInputs).collectFrom([stabilityPoolUtxo], {
+  const validateFrom = Number(
+    currentTime - BigInt(sysParams.stabilityPoolParams.accountProcessingBiasMs) / 2n
+  );
+  const validateTo = Number(
+    currentTime + BigInt(sysParams.stabilityPoolParams.accountProcessingBiasMs) / 2n
+  );
+  const tx = lucid.newTx().validFrom(validateFrom).validTo(validateTo).readFrom(baseRefInputs).collectFrom([stabilityPoolUtxo], {
     kind: "selected",
     inputs: [stabilityPoolUtxo, accountUtxo],
     makeRedeemer: (indices) => serialiseStabilityPoolRedeemer({
@@ -8734,7 +8785,7 @@ async function processSpRequestAuxiliary(stabilityPoolUtxo, accountUtxo, iAssetU
   }).exhaustive();
   return tx;
 }
-async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid, currentSlot) {
+async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE2s2sSnapshotOrefs, sysParams, lucid) {
   const draftTx = processSpRequestAuxiliary(
     stabilityPoolUtxo,
     accountUtxo,
@@ -8743,8 +8794,7 @@ async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE
     sysParams,
     lucid,
     // Placeholder transation fee
-    1n,
-    currentSlot
+    1n
   );
   const fee = (await (await draftTx).complete()).toTransaction().body().fee();
   return processSpRequestAuxiliary(
@@ -8754,8 +8804,7 @@ async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    fee,
-    currentSlot
+    fee
   );
 }
 async function createE2s2sSnapshots(stabilityPoolOref, sysParams, lucid) {
@@ -10094,10 +10143,13 @@ var alwaysFailValidator = {
 };
 
 // src/utils/helper-txs.ts
-async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
-  const scriptAddr = (0, import_lucid55.validatorToAddress)(network, alwaysFailValidator);
-  const txHash = await lucid.newTx().pay.ToAddressWithData(scriptAddr, void 0, {}, scriptRefValidator).complete().then((tx) => tx.sign.withWallet().complete()).then((tx) => tx.submit());
-  await lucid.awaitTx(txHash);
+async function runCreateScriptRefTx(lucid, scriptRefValidator, submissionConfig) {
+  const scriptAddr = (0, import_lucid55.validatorToAddress)(
+    lucid.config().network,
+    alwaysFailValidator
+  );
+  const tx = lucid.newTx().pay.ToAddressWithData(scriptAddr, void 0, {}, scriptRefValidator);
+  const txHash = await runAndAwaitTxBuilder(lucid, tx, submissionConfig);
   return { txHash, outputIndex: 0 };
 }
 
@@ -10157,24 +10209,6 @@ var mkIAssetValidatorFromSP = (params) => {
 
 // src/contracts/initialize/helpers.ts
 var import_ts_pattern21 = require("ts-pattern");
-
-// tests/test-helpers.ts
-var import_fp_ts26 = require("fp-ts");
-async function runAndAwaitTxBuilder(lucid, transaction, extraSigners = []) {
-  const bTx = await transaction.complete();
-  const signatures = [await bTx.partialSign.withWallet()];
-  for (const signer of extraSigners) {
-    lucid.selectWallet.fromSeed(signer);
-    signatures.push(await lucid.fromTx(bTx.toCBOR()).partialSign.withWallet());
-  }
-  const signedTx = bTx.assemble(signatures);
-  const txHash = await signedTx.complete().then((tx) => tx.submit());
-  await lucid.awaitTx(txHash);
-  return txHash;
-}
-
-// src/contracts/initialize/helpers.ts
-var alwaysFailValidatorHash = "ea84d625650d066e1645e3e81d9c70a73f9ed837bd96dc49850ae744";
 var DEFAULT_INIT_OPTIONS = {
   numCdpCreators: 2n,
   numCollectors: 2n,
@@ -10209,18 +10243,27 @@ var INIT_TOKEN_NAMES = {
   snapshotEpochToScaleToSum: "SNAPSHOT_EPOCH_TO_SCALE_TO_SUM",
   account: "SP_ACCOUNT"
 };
-async function mintOneTimeToken(lucid, tokenName, amount) {
+async function mintOneTimeToken(lucid, tokenName, amount, submissionConfig) {
   const utxos = await lucid.wallet().getUtxos();
-  return await runOneShotMintTx(lucid, {
-    referenceOutRef: {
-      txHash: utxos[0].txHash,
-      outputIdx: BigInt(utxos[0].outputIndex)
+  return await runOneShotMintTx(
+    lucid,
+    {
+      referenceOutRef: {
+        txHash: utxos[0].txHash,
+        outputIdx: BigInt(utxos[0].outputIndex)
+      },
+      mintAmounts: [{ tokenName, amount }]
     },
-    mintAmounts: [{ tokenName, amount }]
-  });
+    submissionConfig
+  );
 }
-async function mintOneTimeAsset(lucid, tokenName, amount) {
-  const policyId = await mintOneTimeToken(lucid, (0, import_lucid59.fromText)(tokenName), amount);
+async function mintOneTimeAsset(lucid, tokenName, amount, submissionConfig) {
+  const policyId = await mintOneTimeToken(
+    lucid,
+    (0, import_lucid59.fromText)(tokenName),
+    amount,
+    submissionConfig
+  );
   return {
     currencySymbol: (0, import_lucid59.fromHex)(policyId),
     tokenName: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(tokenName))
@@ -10233,20 +10276,6 @@ function deriveAuthToken(parent, tokenName) {
     tokenName: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(tokenName))
   };
 }
-async function initScriptRef(lucid, validator) {
-  const tx = lucid.newTx().pay.ToContract(
-    (0, import_lucid59.credentialToAddress)(lucid.config().network, {
-      hash: alwaysFailValidatorHash,
-      type: "Script"
-    }),
-    void 0,
-    void 0,
-    validator
-  );
-  const txHash = await tx.complete().then((t) => t.sign.withWallet().complete()).then((t) => t.submit());
-  await lucid.awaitTx(txHash);
-  return { transactionId: txHash, index: 0 };
-}
 async function initCollector(lucid, collectorParams, numCollectors) {
   const tx = lucid.newTx();
   for (let i = 0; i < Number(numCollectors); i++) {
@@ -10261,7 +10290,7 @@ async function initCollector(lucid, collectorParams, numCollectors) {
       }
     );
   }
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function initInterestCollector(lucid, interestCollectionValHash, multisigUtxoNft, numInterestCollectors, interestCollectorUtxoLovelaces) {
   const [pkh, _] = await addrDetails(lucid);
@@ -10272,7 +10301,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
       }
     }
   };
-  await submitTx(
+  await runAndAwaitTxBuilder(
     lucid,
     lucid.newTx().pay.ToContract(
       createScriptAddress(lucid.config().network, interestCollectionValHash),
@@ -10291,7 +10320,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
       (0, import_cardano_offchain_common30.mkLovelacesOf)(interestCollectorUtxoLovelaces)
     );
   }
-  await submitTx(lucid, interestCollectionUtxoDeploymentTx);
+  await runAndAwaitTxBuilder(lucid, interestCollectionUtxoDeploymentTx);
 }
 async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
   const tx = lucid.newTx();
@@ -10309,7 +10338,7 @@ async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
       }
     );
   }
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function initTreasury(lucid, treasuryParams, daoAsset, indyAsset, treasuryIndyAmount, numTreasuryCollectors) {
   const treasuryAddr = createScriptAddress(
@@ -10331,7 +10360,7 @@ async function initTreasury(lucid, treasuryParams, daoAsset, indyAsset, treasury
       value: import_lucid59.Data.void()
     });
   }
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function initStakingManager(lucid, stakingParams) {
   const tx = lucid.newTx().pay.ToContract(
@@ -10350,7 +10379,7 @@ async function initStakingManager(lucid, stakingParams) {
       [stakingParams.stakingManagerNFT[0].unCurrencySymbol + (0, import_lucid59.fromText)(stakingParams.stakingManagerNFT[1].unTokenName)]: 1n
     }
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, pythConfig) {
   return (0, import_ts_pattern21.match)(collateralAsset.priceOracle).returnType().with({ tag: "_indigo_oracle_nft" }, async (val) => {
@@ -10402,7 +10431,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       lucid,
       collateralAsset.interestOracle.tokenName
     );
-    await submitTx(lucid, startInterestOracleTx);
+    await runAndAwaitTxBuilder(lucid, startInterestOracleTx);
     const priceInfo = await handleOracleForCollateralAsset(
       lucid,
       asset,
@@ -10435,7 +10464,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       },
       (0, import_cardano_offchain_common30.mkAssetsOf)(collateralAssetAuthToken, 1n)
     );
-    await submitTx(lucid, collateralAssetTx);
+    await runAndAwaitTxBuilder(lucid, collateralAssetTx);
     collateralAssetInfos.push({
       collateralAsset: collateralAsset.collateralAsset,
       interestOracleNft,
@@ -10457,7 +10486,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       iasset: iassetName,
       stableswapValHash: (0, import_lucid59.fromHex)(stableswapValidatorHash)
     };
-    await submitTx(
+    await runAndAwaitTxBuilder(
       lucid,
       lucid.newTx().pay.ToContract(
         createScriptAddress(
@@ -10494,7 +10523,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     },
     (0, import_cardano_offchain_common30.mkAssetsOf)(iassetToken, 1n)
   );
-  await submitTx(lucid, assetTx);
+  await runAndAwaitTxBuilder(lucid, assetTx);
   const stabilityPoolDatum = {
     iasset: (0, import_lucid59.fromHex)((0, import_lucid59.fromText)(asset.name)),
     state: initSpState,
@@ -10513,7 +10542,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     },
     (0, import_cardano_offchain_common30.mkAssetsOf)(stabilityPoolToken, 1n)
   );
-  await submitTx(lucid, spTx);
+  await runAndAwaitTxBuilder(lucid, spTx);
   return {
     iassetTokenNameAscii: asset.name,
     collateralAssets: collateralAssetInfos
@@ -10535,7 +10564,7 @@ async function initGovernance(lucid, governanceParams, govToken, initialAssets,
     { kind: "inline", value: serialiseGovDatum(datum) },
     (0, import_cardano_offchain_common30.mkAssetsOf)(govToken, 1n)
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
   const script = mkAuthTokenPolicy(asset, (0, import_lucid59.fromText)(tokenName));
@@ -10552,7 +10581,7 @@ async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
     },
     import_lucid59.Data.void()
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 
 // src/contracts/initialize/actions.ts
@@ -10718,23 +10747,30 @@ async function initPyth(lucid) {
       alwaysSucceedValidator
     )
   );
-  const alwaysSucceedRewardAddress = (0, import_lucid63.credentialToRewardAddress)(
-    lucid.config().network,
-    { hash: (0, import_lucid63.validatorToScriptHash)(alwaysSucceedValidator), type: "Script" }
-  );
-  const { registered } = await lucid.rewardAccountAt(
-    alwaysSucceedRewardAddress
-  );
-  if (!registered) {
+  try {
     await runAndAwaitTxBuilder(
       lucid,
-      lucid.newTx().register.Stake(alwaysSucceedRewardAddress)
+      lucid.newTx().register.Stake(
+        (0, import_lucid63.credentialToRewardAddress)(lucid.config().network, {
+          hash: (0, import_lucid63.validatorToScriptHash)(alwaysSucceedValidator),
+          type: "Script"
+        })
+      )
     );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("StakeKeyRegisteredDELEG") && !message.includes("Trying to re-register some already known credentials.")) {
+      throw error;
+    }
   }
   return pythStateAsset;
 }
 
 // src/contracts/initialize/actions.ts
+function isAlreadyRegisteredError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("StakeKeyRegisteredDELEG") || message.includes("Trying to re-register some already known credentials.");
+}
 var DEFAULT_STAKING_CRED = {
   tag: "StakingHash",
   contents: {
@@ -10751,29 +10787,31 @@ async function initPythConfig(lucid, initialAssets, pythStateAsset) {
           fromSysParamsPythFeedParams(val.pythFeedParams)
         );
         const pythFeedValHash = (0, import_lucid64.validatorToScriptHash)(pythFeedValidator);
-        const pythFeedValScriptRef = await initScriptRef(
+        const pythFeedValScriptRef = await runCreateScriptRefTx(
           lucid,
           pythFeedValidator
         );
-        const pythFeedRewardAddress = (0, import_lucid64.credentialToRewardAddress)(
-          lucid.config().network,
-          { hash: (0, import_lucid64.validatorToScriptHash)(pythFeedValidator), type: "Script" }
-        );
-        const { registered } = await lucid.rewardAccountAt(
-          pythFeedRewardAddress
-        );
-        if (!registered) {
+        try {
           await runAndAwaitTxBuilder(
             lucid,
-            lucid.newTx().register.Stake(pythFeedRewardAddress)
+            lucid.newTx().register.Stake(
+              (0, import_lucid64.credentialToRewardAddress)(lucid.config().network, {
+                hash: (0, import_lucid64.validatorToScriptHash)(pythFeedValidator),
+                type: "Script"
+              })
+            )
           );
+        } catch (error) {
+          if (!isAlreadyRegisteredError(error)) throw error;
         }
         const key = `${asset.name}/${(0, import_lucid64.toHex)(collateral.collateralAsset.currencySymbol)}.${(0, import_lucid64.toHex)(collateral.collateralAsset.tokenName)}`;
         return {
           [key]: {
             params: val.pythFeedParams,
             pythFeedValHash,
-            pythFeedValScriptRef: { input: pythFeedValScriptRef }
+            pythFeedValScriptRef: {
+              input: toSystemParamsInput(pythFeedValScriptRef)
+            }
           }
         };
       }).otherwise(() => Promise.resolve({}));
@@ -10807,6 +10845,19 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
   const indyAsset = await mintOneTimeAsset(lucid, tn.indy, totalIndySupply);
   const daoAsset = await mintOneTimeAsset(lucid, tn.dao, 1n);
   const govNftAsset = await mintOneTimeAsset(lucid, tn.govNft, 1n);
+  const cdpCreatorAsset = await mintOneTimeAsset(
+    lucid,
+    tn.cdpCreator,
+    numCdpCreators
+  );
+  const cdpToken = deriveAuthToken(cdpCreatorAsset, tn.cdp);
+  const stakingManagerAsset = await mintOneTimeAsset(
+    lucid,
+    tn.stakingManager,
+    1n
+  );
+  const multisigUtxoNft = await mintOneTimeAsset(lucid, tn.multisigUtxo, 1n);
+  const stakingToken = deriveAuthToken(stakingManagerAsset, tn.staking);
   const pollToken = deriveAuthToken(govNftAsset, tn.pollManager);
   const upgradeToken = deriveAuthToken(pollToken, tn.upgrade);
   const iassetToken = deriveAuthToken(upgradeToken, tn.iasset);
@@ -10832,18 +10883,6 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
   const versionRegistryValHash = (0, import_lucid64.validatorToScriptHash)(
     versionRegistryValidator
   );
-  const cdpCreatorAsset = await mintOneTimeAsset(
-    lucid,
-    tn.cdpCreator,
-    numCdpCreators
-  );
-  const cdpToken = deriveAuthToken(cdpCreatorAsset, tn.cdp);
-  const stakingManagerAsset = await mintOneTimeAsset(
-    lucid,
-    tn.stakingManager,
-    1n
-  );
-  const stakingToken = deriveAuthToken(stakingManagerAsset, tn.staking);
   const collectorParams = {
     stakingManagerNFT: toSystemParamsAsset(stakingManagerAsset),
     stakingToken: toSystemParamsAsset(stakingToken),
@@ -10909,7 +10948,6 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
     treasuryIndyAmount,
     numTreasuryUtxos
   );
-  const multisigUtxoNft = await mintOneTimeAsset(lucid, tn.multisigUtxo, 1n);
   const interestCollectionParams = {
     versionRecordNft: toSystemParamsAsset(versionRecordToken),
     multisigUtxoNft: toSystemParamsAsset(multisigUtxoNft),
@@ -10957,12 +10995,13 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
     lucid.config().network,
     (0, import_lucid64.scriptHashToCredential)(cdpRedeemValHash)
   );
-  const { registered: cdpRedeemRegistered } = await lucid.rewardAccountAt(cdpRedeemRewardAddr);
-  if (!cdpRedeemRegistered) {
+  try {
     await runAndAwaitTxBuilder(
       lucid,
       lucid.newTx().register.Stake(cdpRedeemRewardAddr)
     );
+  } catch (error) {
+    if (!isAlreadyRegisteredError(error)) throw error;
   }
   const cdpParams = {
     cdpAuthToken: toSystemParamsAsset(cdpToken),
@@ -11212,97 +11251,155 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
     },
     scriptReferences: {
       interestCollectionValidatorRef: {
-        input: await initScriptRef(lucid, interestCollectionValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, interestCollectionValidator)
+        )
       },
       robValidatorRef: {
-        input: await initScriptRef(lucid, robValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, robValidator)
+        )
       },
       cdpCreatorValidatorRef: {
-        input: await initScriptRef(lucid, cdpCreatorValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, cdpCreatorValidator)
+        )
       },
       cdpValidatorRef: {
-        input: await initScriptRef(lucid, cdpValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, cdpValidator)
+        )
       },
       cdpRedeemValidatorRef: {
-        input: await initScriptRef(lucid, cdpRedeemValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, cdpRedeemValidator)
+        )
       },
       collectorValidatorRef: {
-        input: await initScriptRef(lucid, collectorValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, collectorValidator)
+        )
       },
       executeValidatorRef: {
-        input: await initScriptRef(lucid, executeValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, executeValidator)
+        )
       },
       pollShardValidatorRef: {
-        input: await initScriptRef(lucid, pollShardValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, pollShardValidator)
+        )
       },
       pollManagerValidatorRef: {
-        input: await initScriptRef(lucid, pollManagerValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, pollManagerValidator)
+        )
       },
       iAssetTokenPolicyRef: {
-        input: await initScriptRef(lucid, assetSymbolPolicy)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, assetSymbolPolicy)
+        )
       },
       stakingValidatorRef: {
-        input: await initScriptRef(
-          lucid,
-          mkStakingValidatorFromSP(stakingParams)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(
+            lucid,
+            mkStakingValidatorFromSP(stakingParams)
+          )
         )
       },
       stabilityPoolValidatorRef: {
-        input: await initScriptRef(lucid, stabilityPoolValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, stabilityPoolValidator)
+        )
       },
       stableswapValidatorRef: {
-        input: await initScriptRef(lucid, stableswapValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, stableswapValidator)
+        )
       },
       treasuryValidatorRef: {
-        input: await initScriptRef(lucid, treasuryValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, treasuryValidator)
+        )
       },
       governanceValidatorRef: {
-        input: await initScriptRef(lucid, govValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, govValidator)
+        )
       },
       versionRegistryValidatorRef: {
-        input: await initScriptRef(lucid, versionRegistryValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, versionRegistryValidator)
+        )
       },
       iassetValidatorRef: {
-        input: await initScriptRef(lucid, iassetValidator)
+        input: toSystemParamsInput(
+          await runCreateScriptRefTx(lucid, iassetValidator)
+        )
       },
       authTokenPolicies: {
         cdpAuthTokenRef: {
-          input: await initScriptRef(lucid, cdpTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, cdpTokenPolicy)
+          )
         },
         iAssetAuthTokenRef: {
-          input: await initScriptRef(lucid, iassetTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, iassetTokenPolicy)
+          )
         },
         accountTokenRef: {
-          input: await initScriptRef(lucid, accountTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, accountTokenPolicy)
+          )
         },
         stabilityPoolAuthTokenRef: {
-          input: await initScriptRef(lucid, stabilityPoolTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, stabilityPoolTokenPolicy)
+          )
         },
         pollManagerTokenRef: {
-          input: await initScriptRef(lucid, pollTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, pollTokenPolicy)
+          )
         },
         stakingTokenRef: {
-          input: await initScriptRef(lucid, stakingTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, stakingTokenPolicy)
+          )
         },
         versionRecordTokenPolicyRef: {
-          input: await initScriptRef(lucid, versionRecordTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, versionRecordTokenPolicy)
+          )
         },
         iAssetTokenRef: {
-          input: await initScriptRef(lucid, assetSymbolPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, assetSymbolPolicy)
+          )
         },
         collateralAssetTokenRef: {
-          input: await initScriptRef(lucid, collateralAssetAuthTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, collateralAssetAuthTokenPolicy)
+          )
         },
         upgradeTokenRef: {
-          input: await initScriptRef(lucid, upgradeTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, upgradeTokenPolicy)
+          )
         },
         stabilityPoolTokenRef: {
-          input: await initScriptRef(lucid, stabilityPoolTokenPolicy)
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(lucid, stabilityPoolTokenPolicy)
+          )
         },
         snapshotEpochToScaleToSumTokenRef: {
-          input: await initScriptRef(
-            lucid,
-            snapshotEpochToScaleToSumTokenPolicy
+          input: toSystemParamsInput(
+            await runCreateScriptRefTx(
+              lucid,
+              snapshotEpochToScaleToSumTokenPolicy
+            )
           )
         }
       }
@@ -11332,7 +11429,7 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
 // src/contracts/iasset/queries.ts
 var import_lucid65 = require("@lucid-evolution/lucid");
 var import_cardano_offchain_common33 = require("@indigo-labs/cardano-offchain-common");
-var import_fp_ts27 = require("fp-ts");
+var import_fp_ts26 = require("fp-ts");
 async function findIAsset(lucid, sysParams, iassetName) {
   const iassetUtxos = await lucid.utxosAtWithUnit(
     createScriptAddress(
@@ -11344,21 +11441,21 @@ async function findIAsset(lucid, sysParams, iassetName) {
     )
   );
   return (0, import_cardano_offchain_common33.matchSingle)(
-    import_fp_ts27.function.pipe(
+    import_fp_ts26.function.pipe(
       iassetUtxos.map(
-        (utxo) => import_fp_ts27.function.pipe(
-          import_fp_ts27.option.fromNullable(utxo.datum),
-          import_fp_ts27.option.flatMap(parseIAssetDatum),
-          import_fp_ts27.option.flatMap((datum) => {
+        (utxo) => import_fp_ts26.function.pipe(
+          import_fp_ts26.option.fromNullable(utxo.datum),
+          import_fp_ts26.option.flatMap(parseIAssetDatum),
+          import_fp_ts26.option.flatMap((datum) => {
             if ((0, import_lucid65.toHex)(datum.assetName) === (0, import_lucid65.toHex)(iassetName)) {
-              return import_fp_ts27.option.some({ utxo, datum });
+              return import_fp_ts26.option.some({ utxo, datum });
             } else {
-              return import_fp_ts27.option.none;
+              return import_fp_ts26.option.none;
             }
           })
         )
       ),
-      import_fp_ts27.array.compact
+      import_fp_ts26.array.compact
     ),
     (res) => new Error("Expected a single IAsset UTXO.: " + JSON.stringify(res))
   );
@@ -11374,21 +11471,21 @@ async function findCollateralAsset(lucid, sysParams, iassetName, collateralAsset
     )
   );
   return (0, import_cardano_offchain_common33.matchSingle)(
-    import_fp_ts27.function.pipe(
+    import_fp_ts26.function.pipe(
       collateralAssetUtxos.map(
-        (utxo) => import_fp_ts27.function.pipe(
-          import_fp_ts27.option.fromNullable(utxo.datum),
-          import_fp_ts27.option.flatMap(parseCollateralAssetDatum),
-          import_fp_ts27.option.flatMap((datum) => {
+        (utxo) => import_fp_ts26.function.pipe(
+          import_fp_ts26.option.fromNullable(utxo.datum),
+          import_fp_ts26.option.flatMap(parseCollateralAssetDatum),
+          import_fp_ts26.option.flatMap((datum) => {
             if ((0, import_cardano_offchain_common33.isSameAssetClass)(datum.collateralAsset, collateralAsset) && (0, import_lucid65.toHex)(iassetName) === (0, import_lucid65.toHex)(datum.iasset)) {
-              return import_fp_ts27.option.some({ utxo, datum });
+              return import_fp_ts26.option.some({ utxo, datum });
             } else {
-              return import_fp_ts27.option.none;
+              return import_fp_ts26.option.none;
             }
           })
         )
       ),
-      import_fp_ts27.array.compact
+      import_fp_ts26.array.compact
     ),
     (res) => new Error(
       "Expected a single Collateral Asset UTXO.: " + JSON.stringify(res)
@@ -11398,12 +11495,12 @@ async function findCollateralAsset(lucid, sysParams, iassetName, collateralAsset
 
 // src/contracts/stableswap/helpers.ts
 var import_lucid66 = require("@lucid-evolution/lucid");
-var import_fp_ts29 = require("fp-ts");
+var import_fp_ts28 = require("fp-ts");
 
 // src/contracts/stableswap/types-new.ts
 var import_cardano_offchain_common34 = require("@indigo-labs/cardano-offchain-common");
 var import_evolution20 = require("@evolution-sdk/evolution");
-var import_fp_ts28 = require("fp-ts");
+var import_fp_ts27 = require("fp-ts");
 var import_effect3 = require("effect");
 var OpaqueData4 = import_effect3.Schema.typeSchema(import_evolution20.Data.DataSchema);
 var StableswapOrderDatumSchema = import_evolution20.TSchema.Struct({
@@ -11445,22 +11542,22 @@ function serialiseStableswapOrderDatum(d) {
 }
 function parseStableswapOrderDatum(datum) {
   try {
-    return import_fp_ts28.option.some(
+    return import_fp_ts27.option.some(
       import_evolution20.Data.withSchema(
         StableswapOrderDatumSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(datum)
     );
   } catch (_) {
-    return import_fp_ts28.option.none;
+    return import_fp_ts27.option.none;
   }
 }
 function parseStableswapOrderDatumOrThrow(datum) {
-  return import_fp_ts28.function.pipe(
+  return import_fp_ts27.function.pipe(
     parseStableswapOrderDatum(datum),
-    import_fp_ts28.option.match(() => {
+    import_fp_ts27.option.match(() => {
       throw new Error("Expected a Stableswap Order datum.");
-    }, import_fp_ts28.function.identity)
+    }, import_fp_ts27.function.identity)
   );
 }
 function serialiseStableswapOutputDatum(d) {
@@ -11477,22 +11574,22 @@ function serialiseStableswapOrderRedeemer(r) {
 }
 function parseStableswapOrderRedeemer(redeemerCborHex) {
   try {
-    return import_fp_ts28.option.some(
+    return import_fp_ts27.option.some(
       import_evolution20.Data.withSchema(
         StableswapOrderRedeemerSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(redeemerCborHex)
     );
   } catch (_) {
-    return import_fp_ts28.option.none;
+    return import_fp_ts27.option.none;
   }
 }
 function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
-  return import_fp_ts28.function.pipe(
+  return import_fp_ts27.function.pipe(
     parseStableswapOrderRedeemer(redeemerCborHex),
-    import_fp_ts28.option.match(() => {
+    import_fp_ts27.option.match(() => {
       throw new Error("Expected a Stableswap Order redeemer.");
-    }, import_fp_ts28.function.identity)
+    }, import_fp_ts27.function.identity)
   );
 }
 
@@ -11748,25 +11845,25 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
       return [];
     }
   });
-  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = import_fp_ts29.function.pipe(
+  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = import_fp_ts28.function.pipe(
     validOrders,
-    import_fp_ts29.array.partition((o) => o.orderType === "REDEEMING"),
+    import_fp_ts28.array.partition((o) => o.orderType === "REDEEMING"),
     ({ left, right }) => ({
       left,
       // Sort the redeeming orders descending.
-      right: import_fp_ts29.function.pipe(
+      right: import_fp_ts28.function.pipe(
         right,
-        import_fp_ts29.array.sort(
-          import_fp_ts29.ord.contramap(
+        import_fp_ts28.array.sort(
+          import_fp_ts28.ord.contramap(
             (o) => o.swapInfo.owedCollateralAsset
-          )(import_fp_ts29.ord.reverse(BigIntOrd))
+          )(import_fp_ts28.ord.reverse(BigIntOrd))
         )
       )
     })
   );
-  const totalCollateralDiff = import_fp_ts29.function.pipe(
+  const totalCollateralDiff = import_fp_ts28.function.pipe(
     validOrders,
-    import_fp_ts29.array.reduce(
+    import_fp_ts28.array.reduce(
       0n,
       (acc, order) => acc + order.swapInfo.suppliedCollateralAsset - order.swapInfo.owedCollateralAsset
     )
@@ -11774,13 +11871,13 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
   if (psmAvailableLiq + totalCollateralDiff >= 0n) {
     return validOrders.map((o) => o.order);
   }
-  const collateralFromMinting = import_fp_ts29.function.pipe(
+  const collateralFromMinting = import_fp_ts28.function.pipe(
     mintingOrders,
-    import_fp_ts29.array.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset)
+    import_fp_ts28.array.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset)
   );
-  const { selected } = import_fp_ts29.function.pipe(
+  const { selected } = import_fp_ts28.function.pipe(
     redeemingOrdersSortedDesc,
-    import_fp_ts29.array.reduce(
+    import_fp_ts28.array.reduce(
       {
         intermediateCollateralAmt: psmAvailableLiq + collateralFromMinting,
         selected: []
@@ -11797,7 +11894,7 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
 // src/contracts/stableswap/queries.ts
 var import_lucid67 = require("@lucid-evolution/lucid");
 var import_cardano_offchain_common36 = require("@indigo-labs/cardano-offchain-common");
-var import_fp_ts30 = require("fp-ts");
+var import_fp_ts29 = require("fp-ts");
 async function findAllStableswapPools(lucid, sysParams) {
   const cdpUtxos = await lucid.utxosAtWithUnit(
     createScriptAddress(
@@ -11808,28 +11905,28 @@ async function findAllStableswapPools(lucid, sysParams) {
       fromSystemParamsAsset(sysParams.stableswapParams.cdpToken)
     )
   );
-  return import_fp_ts30.function.pipe(
+  return import_fp_ts29.function.pipe(
     cdpUtxos.map(
-      (utxo) => import_fp_ts30.function.pipe(
-        import_fp_ts30.option.fromNullable(utxo.datum),
-        import_fp_ts30.option.flatMap(parseStableswapPoolDatum),
-        import_fp_ts30.option.map((datum) => ({ utxo, datum }))
+      (utxo) => import_fp_ts29.function.pipe(
+        import_fp_ts29.option.fromNullable(utxo.datum),
+        import_fp_ts29.option.flatMap(parseStableswapPoolDatum),
+        import_fp_ts29.option.map((datum) => ({ utxo, datum }))
       )
     ),
-    import_fp_ts30.array.compact
+    import_fp_ts29.array.compact
   );
 }
 async function findStableswapPool(lucid, sysParams, iassetName, collateralAsset) {
   const stableswapPools = await findAllStableswapPools(lucid, sysParams);
   return (0, import_cardano_offchain_common36.matchSingle)(
-    import_fp_ts30.function.pipe(
+    import_fp_ts29.function.pipe(
       stableswapPools.map((pool) => {
         if ((0, import_lucid67.toHex)(pool.datum.iasset) === iassetName && (0, import_cardano_offchain_common36.isSameAssetClass)(pool.datum.collateralAsset, collateralAsset)) {
-          return import_fp_ts30.option.some(pool);
+          return import_fp_ts29.option.some(pool);
         }
-        return import_fp_ts30.option.none;
+        return import_fp_ts29.option.none;
       }),
-      import_fp_ts30.array.compact
+      import_fp_ts29.array.compact
     ),
     (res) => new Error(
       "Expected a single stableswap pool UTXO.: " + JSON.stringify(res)
@@ -11840,7 +11937,7 @@ async function findStableswapPool(lucid, sysParams, iassetName, collateralAsset)
 // src/contracts/stableswap/transactions.ts
 var import_lucid68 = require("@lucid-evolution/lucid");
 var import_cardano_offchain_common37 = require("@indigo-labs/cardano-offchain-common");
-var import_fp_ts31 = require("fp-ts");
+var import_fp_ts30 = require("fp-ts");
 async function createStableswapOrder(iasset, collateralAsset, amount, minting, poolDatum, params, lucid, destinationAddress, destinationInlineDatum, maxExecutionFee = BASE_MAX_EXECUTION_FEE, additionalLovelaces = 0n, maxFeeRatio) {
   const myAddress = await lucid.wallet().address();
   const pkh = (0, import_lucid68.paymentCredentialOf)(myAddress);
@@ -11928,7 +12025,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     ]),
     (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
   );
-  if (import_fp_ts31.array.isEmpty(stableswapOrderOrefs)) {
+  if (import_fp_ts30.array.isEmpty(stableswapOrderOrefs)) {
     throw new Error("At least one order must be provided.");
   }
   const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
@@ -11975,9 +12072,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       return res.result;
     }
   );
-  const totalSwapInfo = import_fp_ts31.function.pipe(
+  const totalSwapInfo = import_fp_ts30.function.pipe(
     ordersInfo,
-    import_fp_ts31.array.reduce(
+    import_fp_ts30.array.reduce(
       {
         suppliedCollateralAsset: 0n,
         suppliedIasset: 0n,
@@ -12031,9 +12128,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
   if (amountToMint !== 0n) {
     tx.mintAssets((0, import_cardano_offchain_common37.mkAssetsOf)(iassetAc, amountToMint), import_lucid68.Data.void());
   }
-  import_fp_ts31.function.pipe(
+  import_fp_ts30.function.pipe(
     ordersInfo,
-    import_fp_ts31.array.reduce(tx, (acc, orderInfo) => {
+    import_fp_ts30.array.reduce(tx, (acc, orderInfo) => {
       return acc.collectFrom(
         [orderInfo.order.utxo],
         (0, import_cardano_offchain_common37.isSameOutRef)(orderInfo.order.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
@@ -12325,7 +12422,6 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   initGovernance,
   initInterestCollector,
   initPythConfig,
-  initScriptRef,
   initSpState,
   initStakingManager,
   initSumVal,
@@ -12462,6 +12558,7 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   robCollateralAmtToSpend,
   robIAssetAmtToSpend,
   robSellOrderFilledAssets,
+  runAndAwaitTxBuilder,
   runCreateScriptRefTx,
   runOneShotMintTx,
   scriptRef,
@@ -12507,13 +12604,13 @@ async function updateStableswapPoolFees(stableswapPoolOutRef, stableswapFeeOutRe
   spZeroNegatives,
   startInterestOracle,
   startPriceOracleTx,
-  submitTx,
   sum,
   summariseOrder,
   summarizeActualLeverageRedemptions,
   toAssetClassFromLucid,
   toDataDerivedPythPrice,
   toSystemParamsAsset,
+  toSystemParamsInput,
   treasuryCollect,
   treasuryFeeTx,
   treasuryMerge,