@indigo-labs/indigo-sdk 0.5.16 → 0.6.1

package/dist/index.mjs

@@ -279,6 +279,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: toHex(asset.currencySymbol) },
@@ -363,9 +369,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) => addAssets(acc, utxo.assets), {});
@@ -442,8 +465,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
   );
@@ -498,7 +522,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,
@@ -506,8 +538,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);
 }
@@ -2210,8 +2245,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) => {
@@ -3754,6 +3793,8 @@ function derivePythPrice(derivedPythPrice, messageHex) {
 
 // src/contracts/iasset/helpers.ts
 import * as Core from "@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 match11(priceInfo).returnType().with({ Delisted: P12.any }, () => {
@@ -3834,9 +3875,8 @@ function attachOracle(iasset, collateralAsset, priceInfo, priceOracleOref, pythS
           auxiliaryData: Core.Data.fromCBORHex(Data18.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,
@@ -4323,8 +4363,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,
@@ -4519,8 +4563,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 = F12.pipe(
@@ -7337,10 +7385,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;
 }
 
@@ -8127,9 +8174,8 @@ async function requestSpAccountClosure(accountUtxo, sysParams, lucid, maxTxFee =
     )
   ).addSignerKey(toHex12(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 = matchSingle5(
     await lucid.utxosByOutRef([
       fromSystemParamsScriptRef(
@@ -8145,8 +8191,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({
@@ -8517,7 +8568,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,
@@ -8526,8 +8577,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(
@@ -8537,8 +8587,7 @@ async function processSpRequest(stabilityPoolUtxo, accountUtxo, iAssetUtxo, allE
     allE2s2sSnapshotOrefs,
     sysParams,
     lucid,
-    fee,
-    currentSlot
+    fee
   );
 }
 async function createE2s2sSnapshots(stabilityPoolOref, sysParams, lucid) {
@@ -9929,10 +9978,13 @@ var alwaysFailValidator = {
 };
 
 // src/utils/helper-txs.ts
-async function runCreateScriptRefTx(lucid, scriptRefValidator, network) {
-  const scriptAddr = validatorToAddress3(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 = validatorToAddress3(
+    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 };
 }
 
@@ -10010,24 +10062,6 @@ var mkIAssetValidatorFromSP = (params) => {
 
 // src/contracts/initialize/helpers.ts
 import { match as match20 } from "ts-pattern";
-
-// tests/test-helpers.ts
-import { array as A15, function as F24, option as O20 } from "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,
@@ -10062,18 +10096,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, fromText11(tokenName), amount);
+async function mintOneTimeAsset(lucid, tokenName, amount, submissionConfig) {
+  const policyId = await mintOneTimeToken(
+    lucid,
+    fromText11(tokenName),
+    amount,
+    submissionConfig
+  );
   return {
     currencySymbol: fromHex16(policyId),
     tokenName: fromHex16(fromText11(tokenName))
@@ -10086,20 +10129,6 @@ function deriveAuthToken(parent, tokenName) {
     tokenName: fromHex16(fromText11(tokenName))
   };
 }
-async function initScriptRef(lucid, validator) {
-  const tx = lucid.newTx().pay.ToContract(
-    credentialToAddress4(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++) {
@@ -10114,7 +10143,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);
@@ -10125,7 +10154,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
       }
     }
   };
-  await submitTx(
+  await runAndAwaitTxBuilder(
     lucid,
     lucid.newTx().pay.ToContract(
       createScriptAddress(lucid.config().network, interestCollectionValHash),
@@ -10144,7 +10173,7 @@ async function initInterestCollector(lucid, interestCollectionValHash, multisigU
       mkLovelacesOf7(interestCollectorUtxoLovelaces)
     );
   }
-  await submitTx(lucid, interestCollectionUtxoDeploymentTx);
+  await runAndAwaitTxBuilder(lucid, interestCollectionUtxoDeploymentTx);
 }
 async function initCDPCreator(lucid, cdpCreatorParams, numCdpCreators) {
   const tx = lucid.newTx();
@@ -10162,7 +10191,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(
@@ -10184,7 +10213,7 @@ async function initTreasury(lucid, treasuryParams, daoAsset, indyAsset, treasury
       value: Data49.void()
     });
   }
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function initStakingManager(lucid, stakingParams) {
   const tx = lucid.newTx().pay.ToContract(
@@ -10203,7 +10232,7 @@ async function initStakingManager(lucid, stakingParams) {
       [stakingParams.stakingManagerNFT[0].unCurrencySymbol + fromText11(stakingParams.stakingManagerNFT[1].unTokenName)]: 1n
     }
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function handleOracleForCollateralAsset(lucid, iasset, collateralAsset, pythConfig) {
   return match20(collateralAsset.priceOracle).returnType().with({ tag: "_indigo_oracle_nft" }, async (val) => {
@@ -10255,7 +10284,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,
@@ -10288,7 +10317,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       },
       mkAssetsOf13(collateralAssetAuthToken, 1n)
     );
-    await submitTx(lucid, collateralAssetTx);
+    await runAndAwaitTxBuilder(lucid, collateralAssetTx);
     collateralAssetInfos.push({
       collateralAsset: collateralAsset.collateralAsset,
       interestOracleNft,
@@ -10310,7 +10339,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
       iasset: iassetName,
       stableswapValHash: fromHex16(stableswapValidatorHash)
     };
-    await submitTx(
+    await runAndAwaitTxBuilder(
       lucid,
       lucid.newTx().pay.ToContract(
         createScriptAddress(
@@ -10347,7 +10376,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     },
     mkAssetsOf13(iassetToken, 1n)
   );
-  await submitTx(lucid, assetTx);
+  await runAndAwaitTxBuilder(lucid, assetTx);
   const stabilityPoolDatum = {
     iasset: fromHex16(fromText11(asset.name)),
     state: initSpState,
@@ -10366,7 +10395,7 @@ async function initializeAsset(lucid, iassetParams, iassetToken, collateralAsset
     },
     mkAssetsOf13(stabilityPoolToken, 1n)
   );
-  await submitTx(lucid, spTx);
+  await runAndAwaitTxBuilder(lucid, spTx);
   return {
     iassetTokenNameAscii: asset.name,
     collateralAssets: collateralAssetInfos
@@ -10388,7 +10417,7 @@ async function initGovernance(lucid, governanceParams, govToken, initialAssets,
     { kind: "inline", value: serialiseGovDatum(datum) },
     mkAssetsOf13(govToken, 1n)
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
   const script = mkAuthTokenPolicy(asset, fromText11(tokenName));
@@ -10405,7 +10434,7 @@ async function mintAuthTokenDirect(lucid, asset, tokenName, amount) {
     },
     Data49.void()
   );
-  await submitTx(lucid, tx);
+  await runAndAwaitTxBuilder(lucid, tx);
 }
 
 // src/contracts/initialize/actions.ts
@@ -10593,23 +10622,30 @@ async function initPyth(lucid) {
       alwaysSucceedValidator
     )
   );
-  const alwaysSucceedRewardAddress = credentialToRewardAddress3(
-    lucid.config().network,
-    { hash: validatorToScriptHash4(alwaysSucceedValidator), type: "Script" }
-  );
-  const { registered } = await lucid.rewardAccountAt(
-    alwaysSucceedRewardAddress
-  );
-  if (!registered) {
+  try {
     await runAndAwaitTxBuilder(
       lucid,
-      lucid.newTx().register.Stake(alwaysSucceedRewardAddress)
+      lucid.newTx().register.Stake(
+        credentialToRewardAddress3(lucid.config().network, {
+          hash: validatorToScriptHash4(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: {
@@ -10626,29 +10662,31 @@ async function initPythConfig(lucid, initialAssets, pythStateAsset) {
           fromSysParamsPythFeedParams(val.pythFeedParams)
         );
         const pythFeedValHash = validatorToScriptHash5(pythFeedValidator);
-        const pythFeedValScriptRef = await initScriptRef(
+        const pythFeedValScriptRef = await runCreateScriptRefTx(
           lucid,
           pythFeedValidator
         );
-        const pythFeedRewardAddress = credentialToRewardAddress4(
-          lucid.config().network,
-          { hash: validatorToScriptHash5(pythFeedValidator), type: "Script" }
-        );
-        const { registered } = await lucid.rewardAccountAt(
-          pythFeedRewardAddress
-        );
-        if (!registered) {
+        try {
           await runAndAwaitTxBuilder(
             lucid,
-            lucid.newTx().register.Stake(pythFeedRewardAddress)
+            lucid.newTx().register.Stake(
+              credentialToRewardAddress4(lucid.config().network, {
+                hash: validatorToScriptHash5(pythFeedValidator),
+                type: "Script"
+              })
+            )
           );
+        } catch (error) {
+          if (!isAlreadyRegisteredError(error)) throw error;
         }
         const key = `${asset.name}/${toHex17(collateral.collateralAsset.currencySymbol)}.${toHex17(collateral.collateralAsset.tokenName)}`;
         return {
           [key]: {
             params: val.pythFeedParams,
             pythFeedValHash,
-            pythFeedValScriptRef: { input: pythFeedValScriptRef }
+            pythFeedValScriptRef: {
+              input: toSystemParamsInput(pythFeedValScriptRef)
+            }
           }
         };
       }).otherwise(() => Promise.resolve({}));
@@ -10682,6 +10720,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);
@@ -10707,18 +10758,6 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
   const versionRegistryValHash = validatorToScriptHash5(
     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),
@@ -10784,7 +10823,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),
@@ -10832,12 +10870,13 @@ async function init(lucid, defaultInitialAssets, mkPythBasedAssets = () => [], p
     lucid.config().network,
     scriptHashToCredential4(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),
@@ -11087,97 +11126,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
+            )
           )
         }
       }
@@ -11211,7 +11308,7 @@ import {
   isSameAssetClass as isSameAssetClass5,
   matchSingle as matchSingle6
 } from "@indigo-labs/cardano-offchain-common";
-import { option as O21, array as A16, function as F25 } from "fp-ts";
+import { option as O20, array as A15, function as F24 } from "fp-ts";
 async function findIAsset(lucid, sysParams, iassetName) {
   const iassetUtxos = await lucid.utxosAtWithUnit(
     createScriptAddress(
@@ -11223,21 +11320,21 @@ async function findIAsset(lucid, sysParams, iassetName) {
     )
   );
   return matchSingle6(
-    F25.pipe(
+    F24.pipe(
       iassetUtxos.map(
-        (utxo) => F25.pipe(
-          O21.fromNullable(utxo.datum),
-          O21.flatMap(parseIAssetDatum),
-          O21.flatMap((datum) => {
+        (utxo) => F24.pipe(
+          O20.fromNullable(utxo.datum),
+          O20.flatMap(parseIAssetDatum),
+          O20.flatMap((datum) => {
             if (toHex18(datum.assetName) === toHex18(iassetName)) {
-              return O21.some({ utxo, datum });
+              return O20.some({ utxo, datum });
             } else {
-              return O21.none;
+              return O20.none;
             }
           })
         )
       ),
-      A16.compact
+      A15.compact
     ),
     (res) => new Error("Expected a single IAsset UTXO.: " + JSON.stringify(res))
   );
@@ -11253,21 +11350,21 @@ async function findCollateralAsset(lucid, sysParams, iassetName, collateralAsset
     )
   );
   return matchSingle6(
-    F25.pipe(
+    F24.pipe(
       collateralAssetUtxos.map(
-        (utxo) => F25.pipe(
-          O21.fromNullable(utxo.datum),
-          O21.flatMap(parseCollateralAssetDatum),
-          O21.flatMap((datum) => {
+        (utxo) => F24.pipe(
+          O20.fromNullable(utxo.datum),
+          O20.flatMap(parseCollateralAssetDatum),
+          O20.flatMap((datum) => {
             if (isSameAssetClass5(datum.collateralAsset, collateralAsset) && toHex18(iassetName) === toHex18(datum.iasset)) {
-              return O21.some({ utxo, datum });
+              return O20.some({ utxo, datum });
             } else {
-              return O21.none;
+              return O20.none;
             }
           })
         )
       ),
-      A16.compact
+      A15.compact
     ),
     (res) => new Error(
       "Expected a single Collateral Asset UTXO.: " + JSON.stringify(res)
@@ -11281,7 +11378,7 @@ import {
   fromText as fromText14,
   toHex as toHex19
 } from "@lucid-evolution/lucid";
-import { array as A17, ord as Ord5, function as F27 } from "fp-ts";
+import { array as A16, ord as Ord5, function as F26 } from "fp-ts";
 
 // src/contracts/stableswap/types-new.ts
 import {
@@ -11290,7 +11387,7 @@ import {
   OutputReferenceSchema as OutputReferenceSchema7
 } from "@indigo-labs/cardano-offchain-common";
 import { TSchema as TSchema20, Data as Data51 } from "@evolution-sdk/evolution";
-import { option as O22, function as F26 } from "fp-ts";
+import { option as O21, function as F25 } from "fp-ts";
 import { Schema as Schema4 } from "effect";
 var OpaqueData4 = Schema4.typeSchema(Data51.DataSchema);
 var StableswapOrderDatumSchema = TSchema20.Struct({
@@ -11332,22 +11429,22 @@ function serialiseStableswapOrderDatum(d) {
 }
 function parseStableswapOrderDatum(datum) {
   try {
-    return O22.some(
+    return O21.some(
       Data51.withSchema(
         StableswapOrderDatumSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(datum)
     );
   } catch (_) {
-    return O22.none;
+    return O21.none;
   }
 }
 function parseStableswapOrderDatumOrThrow(datum) {
-  return F26.pipe(
+  return F25.pipe(
     parseStableswapOrderDatum(datum),
-    O22.match(() => {
+    O21.match(() => {
       throw new Error("Expected a Stableswap Order datum.");
-    }, F26.identity)
+    }, F25.identity)
   );
 }
 function serialiseStableswapOutputDatum(d) {
@@ -11364,22 +11461,22 @@ function serialiseStableswapOrderRedeemer(r) {
 }
 function parseStableswapOrderRedeemer(redeemerCborHex) {
   try {
-    return O22.some(
+    return O21.some(
       Data51.withSchema(
         StableswapOrderRedeemerSchema,
         DEFAULT_SCHEMA_OPTIONS
       ).fromCBORHex(redeemerCborHex)
     );
   } catch (_) {
-    return O22.none;
+    return O21.none;
   }
 }
 function parseStableswapOrderRedeemerOrThrow(redeemerCborHex) {
-  return F26.pipe(
+  return F25.pipe(
     parseStableswapOrderRedeemer(redeemerCborHex),
-    O22.match(() => {
+    O21.match(() => {
       throw new Error("Expected a Stableswap Order redeemer.");
-    }, F26.identity)
+    }, F25.identity)
   );
 }
 
@@ -11639,15 +11736,15 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
       return [];
     }
   });
-  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = F27.pipe(
+  const { left: mintingOrders, right: redeemingOrdersSortedDesc } = F26.pipe(
     validOrders,
-    A17.partition((o) => o.orderType === "REDEEMING"),
+    A16.partition((o) => o.orderType === "REDEEMING"),
     ({ left, right }) => ({
       left,
       // Sort the redeeming orders descending.
-      right: F27.pipe(
+      right: F26.pipe(
         right,
-        A17.sort(
+        A16.sort(
           Ord5.contramap(
             (o) => o.swapInfo.owedCollateralAsset
           )(Ord5.reverse(BigIntOrd))
@@ -11655,9 +11752,9 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
       )
     })
   );
-  const totalCollateralDiff = F27.pipe(
+  const totalCollateralDiff = F26.pipe(
     validOrders,
-    A17.reduce(
+    A16.reduce(
       0n,
       (acc, order) => acc + order.swapInfo.suppliedCollateralAsset - order.swapInfo.owedCollateralAsset
     )
@@ -11665,13 +11762,13 @@ function pickValidSatisfiableOrders(lucid, orders, pool, sysParams, psmProcessin
   if (psmAvailableLiq + totalCollateralDiff >= 0n) {
     return validOrders.map((o) => o.order);
   }
-  const collateralFromMinting = F27.pipe(
+  const collateralFromMinting = F26.pipe(
     mintingOrders,
-    A17.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset)
+    A16.reduce(0n, (acc, o) => acc + o.swapInfo.suppliedCollateralAsset)
   );
-  const { selected } = F27.pipe(
+  const { selected } = F26.pipe(
     redeemingOrdersSortedDesc,
-    A17.reduce(
+    A16.reduce(
       {
         intermediateCollateralAmt: psmAvailableLiq + collateralFromMinting,
         selected: []
@@ -11692,7 +11789,7 @@ import {
   isSameAssetClass as isSameAssetClass6,
   matchSingle as matchSingle7
 } from "@indigo-labs/cardano-offchain-common";
-import { array as A18, function as F28, option as O23 } from "fp-ts";
+import { array as A17, function as F27, option as O22 } from "fp-ts";
 async function findAllStableswapPools(lucid, sysParams) {
   const cdpUtxos = await lucid.utxosAtWithUnit(
     createScriptAddress(
@@ -11703,28 +11800,28 @@ async function findAllStableswapPools(lucid, sysParams) {
       fromSystemParamsAsset(sysParams.stableswapParams.cdpToken)
     )
   );
-  return F28.pipe(
+  return F27.pipe(
     cdpUtxos.map(
-      (utxo) => F28.pipe(
-        O23.fromNullable(utxo.datum),
-        O23.flatMap(parseStableswapPoolDatum),
-        O23.map((datum) => ({ utxo, datum }))
+      (utxo) => F27.pipe(
+        O22.fromNullable(utxo.datum),
+        O22.flatMap(parseStableswapPoolDatum),
+        O22.map((datum) => ({ utxo, datum }))
       )
     ),
-    A18.compact
+    A17.compact
   );
 }
 async function findStableswapPool(lucid, sysParams, iassetName, collateralAsset) {
   const stableswapPools = await findAllStableswapPools(lucid, sysParams);
   return matchSingle7(
-    F28.pipe(
+    F27.pipe(
       stableswapPools.map((pool) => {
         if (toHex20(pool.datum.iasset) === iassetName && isSameAssetClass6(pool.datum.collateralAsset, collateralAsset)) {
-          return O23.some(pool);
+          return O22.some(pool);
         }
-        return O23.none;
+        return O22.none;
       }),
-      A18.compact
+      A17.compact
     ),
     (res) => new Error(
       "Expected a single stableswap pool UTXO.: " + JSON.stringify(res)
@@ -11754,7 +11851,7 @@ import {
   isSameOutRef as isSameOutRef2,
   assetClassValueOf as assetClassValueOf13
 } from "@indigo-labs/cardano-offchain-common";
-import { array as A19, function as F29 } from "fp-ts";
+import { array as A18, function as F28 } from "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 = paymentCredentialOf3(myAddress);
@@ -11842,7 +11939,7 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
     ]),
     (_) => new Error("Expected a single iasset token policy Ref Script UTXO")
   );
-  if (A19.isEmpty(stableswapOrderOrefs)) {
+  if (A18.isEmpty(stableswapOrderOrefs)) {
     throw new Error("At least one order must be provided.");
   }
   const stableswapOrderUtxos = await lucid.utxosByOutRef(stableswapOrderOrefs);
@@ -11889,9 +11986,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
       return res.result;
     }
   );
-  const totalSwapInfo = F29.pipe(
+  const totalSwapInfo = F28.pipe(
     ordersInfo,
-    A19.reduce(
+    A18.reduce(
       {
         suppliedCollateralAsset: 0n,
         suppliedIasset: 0n,
@@ -11945,9 +12042,9 @@ async function batchProcessStableswapOrders(stableswapOrderOrefs, stableswapPool
   if (amountToMint !== 0n) {
     tx.mintAssets(mkAssetsOf16(iassetAc, amountToMint), Data53.void());
   }
-  F29.pipe(
+  F28.pipe(
     ordersInfo,
-    A19.reduce(tx, (acc, orderInfo) => {
+    A18.reduce(tx, (acc, orderInfo) => {
       return acc.collectFrom(
         [orderInfo.order.utxo],
         isSameOutRef2(orderInfo.order.utxo, mainOrderUtxo) ? serialiseStableswapOrderRedeemer("BatchProcessStableswapOrders") : {
@@ -12238,7 +12335,6 @@ export {
   initGovernance,
   initInterestCollector,
   initPythConfig,
-  initScriptRef,
   initSpState,
   initStakingManager,
   initSumVal,
@@ -12375,6 +12471,7 @@ export {
   robCollateralAmtToSpend,
   robIAssetAmtToSpend,
   robSellOrderFilledAssets,
+  runAndAwaitTxBuilder,
   runCreateScriptRefTx,
   runOneShotMintTx,
   scriptRef,
@@ -12420,13 +12517,13 @@ export {
   spZeroNegatives,
   startInterestOracle,
   startPriceOracleTx,
-  submitTx,
   sum,
   summariseOrder,
   summarizeActualLeverageRedemptions,
   toAssetClassFromLucid,
   toDataDerivedPythPrice,
   toSystemParamsAsset,
+  toSystemParamsInput,
   treasuryCollect,
   treasuryFeeTx,
   treasuryMerge,