@meshsdk/transaction 1.5.28

package/dist/index.mjs

@@ -0,0 +1,2014 @@
+// src/mesh-tx-builder/tx-builder-core.ts
+import {
+  DEFAULT_REDEEMER_BUDGET,
+  DEFAULT_PROTOCOL_PARAMETERS as DEFAULT_PROTOCOL_PARAMETERS3,
+  emptyTxBuilderBody
+} from "@meshsdk/common";
+import JSONBig from "json-bigint";
+
+// src/utxo-selection/keepRelevant.ts
+import { BigNum as BigNum2 } from "@meshsdk/common";
+
+// src/utxo-selection/common.ts
+import { BigNum } from "@meshsdk/common";
+import { resolveTxFees } from "@meshsdk/common";
+var enoughValueHasBeenSelected = (selection, assets) => {
+  return Array.from(assets, (asset) => ({
+    unit: asset[0],
+    quantity: BigNum.new(asset[1])
+  })).every((asset) => {
+    return selection.filter((utxo) => {
+      return utxo.output.amount.find((a) => a.unit === asset.unit) !== void 0;
+    }).reduce((selectedQuantity, utxo) => {
+      const utxoQuantity = utxo.output.amount.reduce(
+        (quantity, a) => quantity.checkedAdd(
+          BigNum.new(asset.unit === a.unit ? a.quantity : "0")
+        ),
+        BigNum.new("0")
+      );
+      return selectedQuantity.checkedAdd(utxoQuantity);
+    }, BigNum.new("0")).lessThan(asset.quantity) === false;
+  });
+};
+var largestLovelaceQuantity = (utxoA, utxoB) => {
+  const aLovelaceQuantity = BigNum.new(
+    utxoA.output.amount.find((asset) => asset.unit === "lovelace")?.quantity ?? "0"
+  );
+  const bLovelaceQuantity = BigNum.new(
+    utxoB.output.amount.find((asset) => asset.unit === "lovelace")?.quantity ?? "0"
+  );
+  return bLovelaceQuantity.compare(aLovelaceQuantity);
+};
+var maxTxFees = (parameters) => {
+  const { maxTxSize, minFeeA, minFeeB } = parameters;
+  return BigNum.new(resolveTxFees(maxTxSize, minFeeA, minFeeB));
+};
+var multiAssetUTxO = (utxo) => utxo.output.amount.length > 1;
+var selectedLovelaceQuantity = (multiAsset) => {
+  return multiAsset.reduce((sum, utxo) => {
+    const lovelace = utxo.output.amount.find((asset) => asset.unit === "lovelace")?.quantity ?? "0";
+    return sum.checkedAdd(BigNum.new(lovelace));
+  }, BigNum.new("0"));
+};
+var remainingLovelace = (quantity, initialUTxOSet) => {
+  const sortedUTxOs = initialUTxOSet.sort(largestLovelaceQuantity);
+  const requestedOutputSet = /* @__PURE__ */ new Map([["lovelace", quantity]]);
+  const selection = selectValue(sortedUTxOs, requestedOutputSet);
+  return selection;
+};
+var selectValue = (inputUTxO, outputSet, selection = []) => {
+  if (inputUTxO.length === 0 || enoughValueHasBeenSelected(selection, outputSet)) {
+    return selection;
+  }
+  if (valueCanBeSelected(inputUTxO[0], outputSet)) {
+    return selectValue(inputUTxO.slice(1), outputSet, [
+      ...selection,
+      inputUTxO[0]
+    ]);
+  }
+  return selectValue(inputUTxO.slice(1), outputSet, selection);
+};
+var valueCanBeSelected = (utxo, assets) => {
+  return Array.from(assets.keys()).some((unit) => {
+    return utxo.output.amount.find((asset) => asset.unit === unit) !== void 0;
+  });
+};
+
+// src/utxo-selection/keepRelevant.ts
+var keepRelevant = (requiredAssets, inputs, threshold = "5000000") => {
+  const requestedLovelace = BigNum2.new(
+    requiredAssets.get("lovelace") ?? "0"
+  ).checkedAdd(BigNum2.new(threshold));
+  const multiAsset = inputs.filter(
+    (utxo) => utxo.output.amount.filter((asset) => asset.unit !== "lovelace").some((asset) => requiredAssets.has(asset.unit))
+  );
+  const selectedLovelace = selectedLovelaceQuantity(multiAsset);
+  const lovelace = selectedLovelace.lessThan(requestedLovelace) ? remainingLovelace(
+    requestedLovelace.clampedSub(selectedLovelace).toString(),
+    inputs.filter((input) => {
+      return !multiAsset.some(
+        (selectedUtxo) => selectedUtxo.input.txHash === input.input.txHash && selectedUtxo.input.outputIndex === input.input.outputIndex
+      );
+    })
+  ) : [];
+  return [...lovelace, ...multiAsset];
+};
+
+// src/utxo-selection/largestFirst.ts
+import {
+  DEFAULT_PROTOCOL_PARAMETERS,
+  BigNum as BigNum3,
+  resolveTxFees as resolveTxFees2
+} from "@meshsdk/common";
+var largestFirst = (lovelace, initialUTxOSet, includeTxFees = false, { maxTxSize, minFeeA, minFeeB } = DEFAULT_PROTOCOL_PARAMETERS) => {
+  const sortedUTxOs = initialUTxOSet.filter((utxo) => multiAssetUTxO(utxo) === false).sort(largestLovelaceQuantity);
+  const maxTxFees2 = BigNum3.new(resolveTxFees2(maxTxSize, minFeeA, minFeeB));
+  const quantity = includeTxFees ? BigNum3.new(lovelace).checkedAdd(maxTxFees2).toString() : lovelace;
+  const requestedOutputSet = /* @__PURE__ */ new Map([["lovelace", quantity]]);
+  const selection = selectValue(sortedUTxOs, requestedOutputSet);
+  return selection;
+};
+
+// src/utxo-selection/largestFirstMultiAsset.ts
+import {
+  BigNum as BigNum4,
+  DEFAULT_PROTOCOL_PARAMETERS as DEFAULT_PROTOCOL_PARAMETERS2
+} from "@meshsdk/common";
+var largestFirstMultiAsset = (requestedOutputSet, initialUTxOSet, includeTxFees = false, parameters = DEFAULT_PROTOCOL_PARAMETERS2) => {
+  const sortedMultiAssetUTxOs = initialUTxOSet.filter(multiAssetUTxO).sort(largestLovelaceQuantity);
+  const txFees = maxTxFees(parameters);
+  const lovelace = requestedOutputSet.get("lovelace") ?? "0";
+  const quantity = includeTxFees ? BigNum4.new(lovelace).checkedAdd(txFees).toString() : lovelace;
+  requestedOutputSet.set("lovelace", quantity);
+  const selection = selectValue(sortedMultiAssetUTxOs, requestedOutputSet);
+  return selection;
+};
+
+// src/utxo-selection/experimental.ts
+var experimentalSelectUtxos = (requiredAssets, inputs, threshold) => {
+  const totalRequiredAssets = new Map(requiredAssets);
+  totalRequiredAssets.set(
+    "lovelace",
+    String(Number(totalRequiredAssets.get("lovelace") || 0) + Number(threshold))
+  );
+  const utxoMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < inputs.length; i++) {
+    utxoMap.set(i, inputs[i]);
+  }
+  const selectedInputs = /* @__PURE__ */ new Set();
+  const onlyLovelace = /* @__PURE__ */ new Set();
+  const singletons = /* @__PURE__ */ new Set();
+  const pairs = /* @__PURE__ */ new Set();
+  const rest = /* @__PURE__ */ new Set();
+  for (let i = 0; i < inputs.length; i++) {
+    switch (inputs[i].output.amount.length) {
+      case 1: {
+        onlyLovelace.add(i);
+        break;
+      }
+      case 2: {
+        singletons.add(i);
+        break;
+      }
+      case 3: {
+        pairs.add(i);
+        break;
+      }
+      default: {
+        rest.add(i);
+        break;
+      }
+    }
+  }
+  const addUtxoWithAssetAmount = (inputIndex, assetUnit, set) => {
+    const utxo = utxoMap.get(inputIndex);
+    if (!utxo) return;
+    const amount = getAssetAmount(utxo, assetUnit);
+    if (Number(amount) > 0) {
+      selectedInputs.add(inputIndex);
+      set.delete(inputIndex);
+      for (const asset of utxo.output.amount) {
+        totalRequiredAssets.set(
+          asset.unit,
+          String(
+            Number(totalRequiredAssets.get(asset.unit)) - Number(asset.quantity)
+          )
+        );
+      }
+    }
+  };
+  for (const assetUnit of totalRequiredAssets.keys()) {
+    if (assetUnit == "lovelace") continue;
+    for (const inputIndex of singletons) {
+      const assetRequired = totalRequiredAssets.get(assetUnit);
+      if (!assetRequired || Number(assetRequired) <= 0) break;
+      addUtxoWithAssetAmount(inputIndex, assetUnit, singletons);
+    }
+    for (const inputIndex of pairs) {
+      const assetRequired = totalRequiredAssets.get(assetUnit);
+      if (!assetRequired || Number(assetRequired) <= 0) break;
+      addUtxoWithAssetAmount(inputIndex, assetUnit, pairs);
+    }
+    for (const inputIndex of rest) {
+      const assetRequired = totalRequiredAssets.get(assetUnit);
+      if (!assetRequired || Number(assetRequired) <= 0) break;
+      addUtxoWithAssetAmount(inputIndex, assetUnit, rest);
+    }
+  }
+  for (const inputIndex of onlyLovelace) {
+    const assetRequired = totalRequiredAssets.get("lovelace");
+    if (!assetRequired || Number(assetRequired) <= 0) break;
+    addUtxoWithAssetAmount(inputIndex, "lovelace", onlyLovelace);
+  }
+  for (const inputIndex of singletons) {
+    const assetRequired = totalRequiredAssets.get("lovelace");
+    if (!assetRequired || Number(assetRequired) <= 0) break;
+    addUtxoWithAssetAmount(inputIndex, "lovelace", singletons);
+  }
+  for (const inputIndex of pairs) {
+    const assetRequired = totalRequiredAssets.get("lovelace");
+    if (!assetRequired || Number(assetRequired) <= 0) break;
+    addUtxoWithAssetAmount(inputIndex, "lovelace", pairs);
+  }
+  for (const inputIndex of rest) {
+    const assetRequired = totalRequiredAssets.get("lovelace");
+    if (!assetRequired || Number(assetRequired) <= 0) break;
+    addUtxoWithAssetAmount(inputIndex, "lovelace", rest);
+  }
+  for (const assetUnit of totalRequiredAssets.keys()) {
+    if (Number(totalRequiredAssets.get(assetUnit)) > 0) {
+      console.log("Insufficient funds for", assetUnit);
+      console.log(
+        "Remaining quantity",
+        Number(totalRequiredAssets.get(assetUnit))
+      );
+      return [];
+    }
+  }
+  const selectedUtxos = [];
+  for (const inputIndex of selectedInputs) {
+    const utxo = utxoMap.get(inputIndex);
+    if (utxo) {
+      selectedUtxos.push(utxo);
+    }
+  }
+  return selectedUtxos;
+};
+var getAssetAmount = (utxo, assetUnit) => {
+  for (const utxoAsset of utxo.output.amount) {
+    if (utxoAsset.unit == assetUnit) return utxoAsset.quantity;
+  }
+  return "0";
+};
+
+// src/utxo-selection/index.ts
+var UtxoSelection = class {
+  constructor() {
+  }
+  largestFirst(requiredAssets, inputs, threshold = "5000000") {
+    const lovelaceAmount = requiredAssets.get("lovelace") ?? "0";
+    const requiredAssetWithThreshold = BigInt(lovelaceAmount) + BigInt(threshold);
+    return largestFirst(requiredAssetWithThreshold.toString(), inputs, false);
+  }
+  keepRelevant(requiredAssets, inputs, threshold = "5000000") {
+    return keepRelevant(requiredAssets, inputs, threshold);
+  }
+  largestFirstMultiAsset(requiredAssets, inputs, threshold) {
+    const lovelaceAmount = requiredAssets.get("lovelace") ?? "0";
+    requiredAssets.set(
+      "lovelace",
+      (BigInt(lovelaceAmount) + BigInt(threshold)).toString()
+    );
+    return largestFirstMultiAsset(requiredAssets, inputs, false);
+  }
+  experimental(requiredAssets, inputs, threshold) {
+    return experimentalSelectUtxos(requiredAssets, inputs, threshold);
+  }
+};
+
+// src/mesh-tx-builder/tx-builder-core.ts
+var MeshTxBuilderCore = class {
+  constructor() {
+    this.txEvaluationMultiplier = 1.1;
+    this.addingPlutusScriptInput = false;
+    this.addingPlutusMint = false;
+    this.addingPlutusWithdrawal = false;
+    this._protocolParams = DEFAULT_PROTOCOL_PARAMETERS3;
+    /**
+     * Set the input for transaction
+     * @param txHash The transaction hash of the input UTxO
+     * @param txIndex The transaction index of the input UTxO
+     * @param amount The asset amount of index of the input UTxO
+     * @param address The address of the input UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.txIn = (txHash, txIndex, amount, address) => {
+      if (this.txInQueueItem) {
+        this.queueInput();
+      }
+      if (!this.addingPlutusScriptInput) {
+        this.txInQueueItem = {
+          type: "PubKey",
+          txIn: {
+            txHash,
+            txIndex,
+            amount,
+            address
+          }
+        };
+      } else {
+        this.txInQueueItem = {
+          type: "Script",
+          txIn: {
+            txHash,
+            txIndex,
+            amount,
+            address
+          },
+          scriptTxIn: {}
+        };
+      }
+      this.addingPlutusScriptInput = false;
+      return this;
+    };
+    /**
+     * Set the script for transaction input
+     * @param {string} scriptCbor The CborHex of the script
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    this.txInScript = (scriptCbor) => {
+      if (!this.txInQueueItem) throw Error("Undefined input");
+      if (this.txInQueueItem.type === "PubKey") {
+        this.txInQueueItem = {
+          type: "SimpleScript",
+          txIn: this.txInQueueItem.txIn,
+          simpleScriptTxIn: {
+            scriptSource: {
+              type: "Provided",
+              script: scriptCbor
+            }
+          }
+        };
+      }
+      if (this.txInQueueItem.type === "Script") {
+        this.txInQueueItem.scriptTxIn.scriptSource = {
+          type: "Provided",
+          script: {
+            code: scriptCbor,
+            version: this.plutusSpendingScriptVersion || "V2"
+          }
+        };
+      }
+      return this;
+    };
+    /**
+     * Set the input datum for transaction input
+     * @param datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    this.txInDatumValue = (datum, type = "Mesh") => {
+      if (!this.txInQueueItem) throw Error("Undefined input");
+      if (this.txInQueueItem.type === "PubKey")
+        throw Error("Datum value attempted to be called a non script input");
+      if (this.txInQueueItem.type === "SimpleScript")
+        throw Error(
+          "Datum value attempted to be called on a simple script input"
+        );
+      let content = datum;
+      if (type === "JSON") {
+        content = this.castRawDataToJsonString(datum);
+      }
+      if (type === "Mesh") {
+        this.txInQueueItem.scriptTxIn.datumSource = {
+          type: "Provided",
+          data: {
+            type,
+            content: datum
+          }
+        };
+        return this;
+      }
+      this.txInQueueItem.scriptTxIn.datumSource = {
+        type: "Provided",
+        data: {
+          type,
+          content
+        }
+      };
+      return this;
+    };
+    /**
+     * Tell the transaction builder that the input UTxO has inlined datum
+     * @returns The MeshTxBuilder instance
+     */
+    this.txInInlineDatumPresent = () => {
+      if (!this.txInQueueItem) throw Error("Undefined input");
+      if (this.txInQueueItem.type === "PubKey")
+        throw Error(
+          "Inline datum present attempted to be called a non script input"
+        );
+      if (this.txInQueueItem.type === "SimpleScript")
+        throw Error(
+          "Inline datum present attempted to be called on a simple script input"
+        );
+      const { txHash, txIndex } = this.txInQueueItem.txIn;
+      if (txHash && txIndex.toString()) {
+        this.txInQueueItem.scriptTxIn.datumSource = {
+          type: "Inline",
+          txHash,
+          txIndex
+        };
+      }
+      return this;
+    };
+    // /**
+    //  * Native script - Set the reference input where it would also be spent in the transaction
+    //  * @param txHash The transaction hash of the reference UTxO
+    //  * @param txIndex The transaction index of the reference UTxO
+    //  * @param spendingScriptHash The script hash of the spending script
+    //  * @returns The MeshTxBuilder instance
+    //  */
+    // simpleScriptTxInReference = (
+    //   txHash: string,
+    //   txIndex: number,
+    //   spendingScriptHash?: string
+    // ) => {
+    //   if (!this.txInQueueItem) throw Error('Undefined input');
+    //   if (this.txInQueueItem.type === 'PubKey')
+    //     throw Error(
+    //       'Spending tx in reference attempted to be called a non script input'
+    //     );
+    //   this.txInQueueItem.scriptTxIn.scriptSource = {
+    //     type: 'Inline',
+    //     txInInfo: {
+    //       txHash,
+    //       txIndex,
+    //       spendingScriptHash,
+    //     },
+    //   };
+    //   return this;
+    // };
+    /**
+     * Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    this.txInRedeemerValue = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      if (!this.txInQueueItem) throw Error("Undefined input");
+      if (this.txInQueueItem.type === "PubKey")
+        throw Error(
+          "Spending tx in reference redeemer attempted to be called a non script input"
+        );
+      if (this.txInQueueItem.type === "SimpleScript")
+        throw Error(
+          "Spending tx in reference redeemer attempted to be called on a simple script input"
+        );
+      this.txInQueueItem.scriptTxIn.redeemer = this.castBuilderDataToRedeemer(
+        redeemer,
+        type,
+        exUnits
+      );
+      return this;
+    };
+    /**
+     * Set the output for transaction
+     * @param {string} address The recipient of the output
+     * @param {Asset[]} amount The amount of other native assets attached with UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.txOut = (address, amount) => {
+      if (this.txOutput) {
+        this.meshTxBuilderBody.outputs.push(this.txOutput);
+        this.txOutput = void 0;
+      }
+      this.txOutput = {
+        address,
+        amount
+      };
+      return this;
+    };
+    /**
+     * Set the output datum hash for transaction
+     * @param datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    this.txOutDatumHashValue = (datum, type = "Mesh") => {
+      let content = datum;
+      if (this.txOutput) {
+        if (type === "Mesh") {
+          this.txOutput.datum = {
+            type: "Hash",
+            data: {
+              type,
+              content
+            }
+          };
+          return this;
+        }
+        if (type === "JSON") {
+          content = this.castRawDataToJsonString(datum);
+        }
+        this.txOutput.datum = {
+          type: "Hash",
+          data: {
+            type,
+            content
+          }
+        };
+      }
+      return this;
+    };
+    /**
+     * Set the output inline datum for transaction
+     * @param datum The datum in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The datum type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @returns The MeshTxBuilder instance
+     */
+    this.txOutInlineDatumValue = (datum, type = "Mesh") => {
+      let content = datum;
+      if (this.txOutput) {
+        if (type === "Mesh") {
+          this.txOutput.datum = {
+            type: "Inline",
+            data: {
+              type,
+              content
+            }
+          };
+          return this;
+        }
+        if (type === "JSON") {
+          content = this.castRawDataToJsonString(datum);
+        }
+        this.txOutput.datum = {
+          type: "Inline",
+          data: {
+            type,
+            content
+          }
+        };
+      }
+      return this;
+    };
+    /**
+     * Set the reference script to be attached with the output
+     * @param scriptCbor The CBOR hex of the script to be attached to UTxO as reference script
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    this.txOutReferenceScript = (scriptCbor, version = "V2") => {
+      if (this.txOutput) {
+        this.txOutput.referenceScript = { code: scriptCbor, version };
+      }
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V1 Plutus spending scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.spendingPlutusScriptV1 = () => {
+      this.addingPlutusScriptInput = true;
+      this.plutusSpendingScriptVersion = "V1";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V2 Plutus spending scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.spendingPlutusScriptV2 = () => {
+      this.addingPlutusScriptInput = true;
+      this.plutusSpendingScriptVersion = "V2";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V3 Plutus spending scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.spendingPlutusScriptV3 = () => {
+      this.addingPlutusScriptInput = true;
+      this.plutusSpendingScriptVersion = "V3";
+      return this;
+    };
+    /**
+     * Set the reference input where it would also be spent in the transaction
+     * @param txHash The transaction hash of the reference UTxO
+     * @param txIndex The transaction index of the reference UTxO
+     * @param spendingScriptHash The script hash of the spending script
+     * @returns The MeshTxBuilder instance
+     */
+    this.spendingTxInReference = (txHash, txIndex, spendingScriptHash) => {
+      if (!this.txInQueueItem) throw Error("Undefined input");
+      if (this.txInQueueItem.type === "PubKey")
+        throw Error(
+          "Spending tx in reference attempted to be called a non script input"
+        );
+      if (this.txInQueueItem.type === "SimpleScript")
+        throw Error(
+          "Spending tx in reference attempted to be called on a simple script input"
+        );
+      this.txInQueueItem.scriptTxIn.scriptSource = {
+        type: "Inline",
+        txHash,
+        txIndex,
+        scriptHash: spendingScriptHash,
+        version: this.plutusSpendingScriptVersion || "V2",
+        scriptSize: "0"
+        // TODO
+      };
+      return this;
+    };
+    /**
+     * [Alias of txInInlineDatumPresent] Set the instruction that the reference input has inline datum
+     * @returns The MeshTxBuilder instance
+     */
+    // Unsure how this is different from the --tx-in-inline-datum-present flag
+    // It seems to just be different based on if the script is a reference input
+    this.spendingReferenceTxInInlineDatumPresent = () => {
+      this.txInInlineDatumPresent();
+      return this;
+    };
+    /**
+     * [Alias of txInRedeemerValue] Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    this.spendingReferenceTxInRedeemerValue = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      this.txInRedeemerValue(redeemer, type, exUnits);
+      return this;
+    };
+    /**
+     * Specify a read only reference input. This reference input is not witnessing anything it is simply provided in the plutus script context.
+     * @param txHash The transaction hash of the reference UTxO
+     * @param txIndex The transaction index of the reference UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.readOnlyTxInReference = (txHash, txIndex) => {
+      this.meshTxBuilderBody.referenceInputs.push({ txHash, txIndex });
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V1 Plutus minting scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintPlutusScriptV1 = () => {
+      this.addingPlutusMint = true;
+      this.plutusMintingScriptVersion = "V1";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V2 Plutus minting scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintPlutusScriptV2 = () => {
+      this.addingPlutusMint = true;
+      this.plutusMintingScriptVersion = "V2";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V3 Plutus minting scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintPlutusScriptV3 = () => {
+      this.addingPlutusMint = true;
+      this.plutusMintingScriptVersion = "V3";
+      return this;
+    };
+    /**
+     * Set the minting value of transaction
+     * @param quantity The quantity of asset to be minted
+     * @param policy The policy id of the asset to be minted
+     * @param name The hex of token name of the asset to be minted
+     * @returns The MeshTxBuilder instance
+     */
+    this.mint = (quantity, policy, name) => {
+      if (this.mintItem) {
+        this.queueMint();
+      }
+      this.mintItem = {
+        type: this.addingPlutusMint ? "Plutus" : "Native",
+        policyId: policy,
+        assetName: name,
+        amount: quantity
+      };
+      this.addingPlutusMint = false;
+      return this;
+    };
+    /**
+     * Set the minting script of current mint
+     * @param scriptCBOR The CBOR hex of the minting policy script
+     * @param version Optional - The Plutus script version
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintingScript = (scriptCBOR) => {
+      if (!this.mintItem) throw Error("Undefined mint");
+      if (!this.mintItem.type) throw Error("Mint information missing");
+      if (this.mintItem.type === "Native") {
+        this.mintItem.scriptSource = {
+          type: "Provided",
+          scriptCode: scriptCBOR
+        };
+      }
+      if (this.mintItem.type === "Plutus") {
+        this.mintItem.scriptSource = {
+          type: "Provided",
+          script: {
+            code: scriptCBOR,
+            version: this.plutusMintingScriptVersion || "V2"
+          }
+        };
+      }
+      return this;
+    };
+    /**
+     * Use reference script for minting
+     * @param txHash The transaction hash of the UTxO
+     * @param txIndex The transaction index of the UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintTxInReference = (txHash, txIndex) => {
+      if (!this.mintItem) throw Error("Undefined mint");
+      if (!this.mintItem.type) throw Error("Mint information missing");
+      if (this.mintItem.type == "Native") {
+        throw Error(
+          "Mint tx in reference can only be used on plutus script tokens"
+        );
+      }
+      if (!this.mintItem.policyId)
+        throw Error("PolicyId information missing from mint asset");
+      this.mintItem.scriptSource = {
+        type: "Inline",
+        txHash,
+        txIndex,
+        version: this.plutusMintingScriptVersion,
+        scriptSize: "0",
+        // TODO
+        scriptHash: ""
+        // TODO
+      };
+      return this;
+    };
+    /**
+     * Set the redeemer for minting
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintReferenceTxInRedeemerValue = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      if (!this.mintItem) throw Error("Undefined mint");
+      if (this.mintItem.type == "Native") {
+        throw Error(
+          "Mint tx in reference can only be used on plutus script tokens"
+        );
+      } else if (this.mintItem.type == "Plutus") {
+        if (!this.mintItem.policyId)
+          throw Error("PolicyId information missing from mint asset");
+      }
+      this.mintItem.redeemer = this.castBuilderDataToRedeemer(
+        redeemer,
+        type,
+        exUnits
+      );
+      return this;
+    };
+    /**
+     * Set the redeemer for the reference input to be spent in same transaction
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    this.mintRedeemerValue = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      this.mintReferenceTxInRedeemerValue(redeemer, type, exUnits);
+      return this;
+    };
+    /**
+     * Set the required signer of the transaction
+     * @param pubKeyHash The PubKeyHash of the required signer
+     * @returns The MeshTxBuilder instance
+     */
+    this.requiredSignerHash = (pubKeyHash) => {
+      this.meshTxBuilderBody.requiredSignatures.push(pubKeyHash);
+      return this;
+    };
+    /**
+     * Set the collateral UTxO for the transaction
+     * @param txHash The transaction hash of the collateral UTxO
+     * @param txIndex The transaction index of the collateral UTxO
+     * @param amount The asset amount of index of the collateral UTxO
+     * @param address The address of the collateral UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.txInCollateral = (txHash, txIndex, amount, address) => {
+      if (this.collateralQueueItem) {
+        this.meshTxBuilderBody.collaterals.push(this.collateralQueueItem);
+      }
+      this.collateralQueueItem = {
+        type: "PubKey",
+        txIn: {
+          txHash,
+          txIndex,
+          amount,
+          address
+        }
+      };
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V1 Plutus withdrawal scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalPlutusScriptV1 = () => {
+      this.addingPlutusWithdrawal = true;
+      this.plutusWithdrawalScriptVersion = "V1";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V2 Plutus withdrawal scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalPlutusScriptV2 = () => {
+      this.addingPlutusWithdrawal = true;
+      this.plutusWithdrawalScriptVersion = "V2";
+      return this;
+    };
+    /**
+     * Set the instruction that it is currently using V3 Plutus withdrawal scripts
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalPlutusScriptV3 = () => {
+      this.addingPlutusWithdrawal = true;
+      this.plutusWithdrawalScriptVersion = "V3";
+      return this;
+    };
+    /**
+     * Withdraw stake rewards in the MeshTxBuilder instance
+     * @param stakeAddress The address corresponding to the stake key
+     * @param coin The amount of lovelaces in the withdrawal
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawal = (stakeAddress, coin) => {
+      if (this.withdrawalItem) {
+        this.queueWithdrawal();
+      }
+      if (this.addingPlutusWithdrawal) {
+        const withdrawal2 = {
+          plutusScriptWithdrawal: {
+            address: stakeAddress,
+            coin
+          }
+        };
+        this.meshTxBuilderBody.withdrawals.push(withdrawal2);
+        return this;
+      }
+      const withdrawal = {
+        pubKeyWithdrawal: {
+          address: stakeAddress,
+          coin
+        }
+      };
+      this.meshTxBuilderBody.withdrawals.push(withdrawal);
+      return this;
+    };
+    /**
+     * Add a withdrawal script to the MeshTxBuilder instance
+     * @param scriptCbor The script in CBOR format
+     * @param version The language version
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalScript = (scriptCbor, version) => {
+      if (!this.withdrawalItem)
+        throw Error("withdrawalScript: Undefined withdrawal");
+      if (!("plutusScriptWithdrawal" in this.withdrawalItem))
+        throw Error("withdrawalScript: Adding script to non plutus withdrawal");
+      this.withdrawalItem.plutusScriptWithdrawal.scriptSource = {
+        type: "Provided",
+        script: {
+          code: scriptCbor,
+          version: this.plutusWithdrawalScriptVersion || "V2"
+        }
+      };
+      return this;
+    };
+    /**
+     * Add a withdrawal reference to the MeshTxBuilder instance
+     * @param txHash The transaction hash of reference UTxO
+     * @param txIndex The transaction index of reference UTxO
+     * @param withdrawalScriptHash The script hash of the withdrawal script
+     * @param scriptSize The script size of the withdrawal script
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalTxInReference = (txHash, txIndex, withdrawalScriptHash, scriptSize) => {
+      if (!this.withdrawalItem)
+        throw Error("withdrawalTxInReference: Undefined withdrawal");
+      if (!("plutusScriptWithdrawal" in this.withdrawalItem))
+        throw Error(
+          "withdrawalTxInReference: Adding script reference to non plutus withdrawal"
+        );
+      this.withdrawalItem.plutusScriptWithdrawal.scriptSource = {
+        type: "Inline",
+        txHash,
+        txIndex,
+        scriptHash: withdrawalScriptHash,
+        version: this.plutusWithdrawalScriptVersion || "V2",
+        scriptSize: scriptSize || "0"
+      };
+    };
+    /**
+     * Set the transaction withdrawal redeemer value in the MeshTxBuilder instance
+     * @param redeemer The redeemer in Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param type The redeemer data type, either Mesh Data type, JSON in raw constructor like format, or CBOR hex string
+     * @param exUnits The execution units budget for the redeemer
+     * @returns The MeshTxBuilder instance
+     */
+    this.withdrawalRedeemerValue = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      if (!this.withdrawalItem)
+        throw Error("withdrawalRedeemerValue: Undefined withdrawal");
+      if (!("plutusScriptWithdrawal" in this.withdrawalItem))
+        throw Error(
+          "withdrawalRedeemerValue: Adding redeemer to non plutus withdrawal"
+        );
+      this.withdrawalItem.plutusScriptWithdrawal.redeemer = this.castBuilderDataToRedeemer(redeemer, type, exUnits);
+      return this;
+    };
+    /**
+     * Creates a pool registration certificate, and adds it to the transaction
+     * @param poolParams Parameters for pool registration
+     * @returns The MeshTxBuilder instance
+     */
+    this.registerPoolCertificate = (poolParams) => {
+      this.meshTxBuilderBody.certificates.push({
+        type: "RegisterPool",
+        poolParams
+      });
+      return this;
+    };
+    /**
+     * Creates a stake registration certificate, and adds it to the transaction
+     * @param stakeKeyHash The keyHash of the stake key
+     * @returns The MeshTxBuilder instance
+     */
+    this.registerStakeCertificate = (stakeKeyHash) => {
+      this.meshTxBuilderBody.certificates.push({
+        type: "RegisterStake",
+        stakeKeyHash
+      });
+      return this;
+    };
+    /**
+     * Creates a stake delegation certificate, and adds it to the transaction
+     * This will delegate stake from the corresponding stake address to the pool
+     * @param stakeKeyHash The keyHash of the stake key
+     * @param poolId poolId can be in either bech32 or hex form
+     * @returns The MeshTxBuilder instance
+     */
+    this.delegateStakeCertificate = (stakeKeyHash, poolId) => {
+      this.meshTxBuilderBody.certificates.push({
+        type: "DelegateStake",
+        stakeKeyHash,
+        poolId
+      });
+      return this;
+    };
+    /**
+     * Creates a stake deregister certificate, and adds it to the transaction
+     * @param stakeKeyHash The keyHash of the stake key
+     * @returns The MeshTxBuilder instance
+     */
+    this.deregisterStakeCertificate = (stakeKeyHash) => {
+      this.meshTxBuilderBody.certificates.push({
+        type: "DeregisterStake",
+        stakeKeyHash
+      });
+      return this;
+    };
+    /**
+     * Creates a pool retire certificate, and adds it to the transaction
+     * @param poolId poolId can be in either bech32 or hex form
+     * @param epoch The intended epoch to retire the pool
+     * @returns The MeshTxBuilder instance
+     */
+    this.retirePoolCertificate = (poolId, epoch) => {
+      this.meshTxBuilderBody.certificates.push({
+        type: "RetirePool",
+        poolId,
+        epoch
+      });
+      return this;
+    };
+    /**
+     * Configure the address to accept change UTxO
+     * @param addr The address to accept change UTxO
+     * @returns The MeshTxBuilder instance
+     */
+    this.changeAddress = (addr) => {
+      this.meshTxBuilderBody.changeAddress = addr;
+      return this;
+    };
+    /**
+     * Set the transaction valid interval to be valid only after the slot
+     * @param slot The transaction is valid only after this slot
+     * @returns The MeshTxBuilder instance
+     */
+    this.invalidBefore = (slot) => {
+      this.meshTxBuilderBody.validityRange.invalidBefore = slot;
+      return this;
+    };
+    /**
+     * Set the transaction valid interval to be valid only before the slot
+     * @param slot The transaction is valid only before this slot
+     * @returns The MeshTxBuilder instance
+     */
+    this.invalidHereafter = (slot) => {
+      this.meshTxBuilderBody.validityRange.invalidHereafter = slot;
+      return this;
+    };
+    /**
+     * Add metadata to the transaction
+     * @param tag The tag of the metadata
+     * @param metadata The metadata in any format
+     * @returns The MeshTxBuilder instance
+     */
+    this.metadataValue = (tag, metadata) => {
+      const metadataString = JSONBig.stringify(metadata);
+      this.meshTxBuilderBody.metadata.push({ tag, metadata: metadataString });
+      return this;
+    };
+    /**
+     * Sign the transaction with the private key
+     * @param skeyHex The private key in cborHex (with or without 5820 prefix, i.e. the format when generated from cardano-cli)
+     * @returns
+     */
+    this.signingKey = (skeyHex) => {
+      this.meshTxBuilderBody.signingKey.push(skeyHex);
+      return this;
+    };
+    /**
+     * EXPERIMENTAL - Selects utxos to fill output value and puts them into inputs
+     * @param extraInputs The inputs already placed into the object will remain, these extra inputs will be used to fill the remaining  value needed
+     * @param threshold Extra value needed to be selected for, usually for paying fees and min UTxO value of change output
+     */
+    this.selectUtxosFrom = (extraInputs, threshold = 5e6) => {
+      this.meshTxBuilderBody.extraInputs = extraInputs;
+      this.meshTxBuilderBody.selectionThreshold = threshold;
+      return this;
+    };
+    /**
+     * Set the protocol parameters to be used for the transaction other than the default one
+     * @param params (Part of) the protocol parameters to be used for the transaction
+     * @returns The MeshTxBuilder instance
+     */
+    this.protocolParams = (params) => {
+      const updatedParams = { ...DEFAULT_PROTOCOL_PARAMETERS3, ...params };
+      this._protocolParams = updatedParams;
+      return this;
+    };
+    this.queueAllLastItem = () => {
+      if (this.txOutput) {
+        this.meshTxBuilderBody.outputs.push(this.txOutput);
+        this.txOutput = void 0;
+      }
+      if (this.txInQueueItem) {
+        this.queueInput();
+      }
+      if (this.collateralQueueItem) {
+        this.meshTxBuilderBody.collaterals.push(this.collateralQueueItem);
+        this.collateralQueueItem = void 0;
+      }
+      if (this.mintItem) {
+        this.queueMint();
+      }
+      if (this.withdrawalItem) {
+        this.queueWithdrawal();
+      }
+    };
+    this.queueInput = () => {
+      if (!this.txInQueueItem) throw Error("queueInput: Undefined input");
+      if (this.txInQueueItem.type === "Script") {
+        if (!this.txInQueueItem.scriptTxIn) {
+          throw Error(
+            "queueInput: Script input does not contain script, datum, or redeemer information"
+          );
+        } else {
+          if (!this.txInQueueItem.scriptTxIn.datumSource)
+            throw Error(
+              "queueInput: Script input does not contain datum information"
+            );
+          if (!this.txInQueueItem.scriptTxIn.redeemer)
+            throw Error(
+              "queueInput: Script input does not contain redeemer information"
+            );
+          if (!this.txInQueueItem.scriptTxIn.scriptSource)
+            throw Error(
+              "queueInput: Script input does not contain script information"
+            );
+        }
+      }
+      this.meshTxBuilderBody.inputs.push(this.txInQueueItem);
+      this.txInQueueItem = void 0;
+    };
+    this.queueMint = () => {
+      if (!this.mintItem) throw Error("queueMint: Undefined mint");
+      if (!this.mintItem.scriptSource)
+        throw Error("queueMint: Missing mint script information");
+      this.meshTxBuilderBody.mints.push(this.mintItem);
+      this.mintItem = void 0;
+    };
+    this.queueWithdrawal = () => {
+      if (!this.withdrawalItem)
+        throw Error("queueWithdrawal: Undefined withdrawal");
+      if ("plutusScriptWithdrawal" in this.withdrawalItem) {
+        if (!this.withdrawalItem.plutusScriptWithdrawal.scriptSource) {
+          throw Error("queueWithdrawal: Missing withdrawal script information");
+        }
+        if (!this.withdrawalItem.plutusScriptWithdrawal.redeemer) {
+          throw Error("queueWithdrawal: Missing withdrawal redeemer information");
+        }
+      }
+      this.meshTxBuilderBody.withdrawals.push(this.withdrawalItem);
+      this.withdrawalItem = void 0;
+    };
+    this.castRawDataToJsonString = (rawData) => {
+      if (typeof rawData === "object") {
+        return JSONBig.stringify(rawData);
+      } else {
+        return rawData;
+      }
+    };
+    this.castBuilderDataToRedeemer = (redeemer, type = "Mesh", exUnits = { ...DEFAULT_REDEEMER_BUDGET }) => {
+      let red;
+      let content = redeemer;
+      if (type === "Mesh") {
+        red = {
+          data: {
+            type,
+            content
+          },
+          exUnits
+        };
+        return red;
+      }
+      if (type === "JSON") {
+        content = this.castRawDataToJsonString(redeemer);
+      }
+      red = {
+        data: {
+          type,
+          content
+        },
+        exUnits
+      };
+      return red;
+    };
+    this.updateRedeemer = (meshTxBuilderBody, txEvaluation) => {
+      txEvaluation.forEach((redeemerEvaluation) => {
+        switch (redeemerEvaluation.tag) {
+          case "SPEND": {
+            const input = meshTxBuilderBody.inputs[redeemerEvaluation.index];
+            if (input.type == "Script" && input.scriptTxIn.redeemer) {
+              input.scriptTxIn.redeemer.exUnits.mem = Math.floor(
+                redeemerEvaluation.budget.mem * this.txEvaluationMultiplier
+              );
+              input.scriptTxIn.redeemer.exUnits.steps = Math.floor(
+                redeemerEvaluation.budget.steps * this.txEvaluationMultiplier
+              );
+            }
+            break;
+          }
+          case "MINT": {
+            const mint = meshTxBuilderBody.mints[redeemerEvaluation.index];
+            if (mint.type == "Plutus" && mint.redeemer) {
+              mint.redeemer.exUnits.mem = Math.floor(
+                redeemerEvaluation.budget.mem * this.txEvaluationMultiplier
+              );
+              mint.redeemer.exUnits.steps = Math.floor(
+                redeemerEvaluation.budget.steps * this.txEvaluationMultiplier
+              );
+            }
+            break;
+          }
+          case "CERT":
+            break;
+          case "REWARD":
+            break;
+        }
+      });
+    };
+    this.addUtxosFromSelection = () => {
+      const requiredAssets = this.meshTxBuilderBody.outputs.reduce(
+        (map, output) => {
+          const outputAmount = output.amount;
+          outputAmount.forEach((asset) => {
+            const { unit, quantity } = asset;
+            const existingQuantity = Number(map.get(unit)) || 0;
+            map.set(unit, String(existingQuantity + Number(quantity)));
+          });
+          return map;
+        },
+        /* @__PURE__ */ new Map()
+      );
+      this.meshTxBuilderBody.inputs.reduce((map, input) => {
+        const inputAmount = input.txIn.amount;
+        inputAmount?.forEach((asset) => {
+          const { unit, quantity } = asset;
+          const existingQuantity = Number(map.get(unit)) || 0;
+          map.set(unit, String(existingQuantity - Number(quantity)));
+        });
+        return map;
+      }, requiredAssets);
+      this.meshTxBuilderBody.mints.reduce((map, mint) => {
+        const mintAmount = {
+          unit: mint.policyId + mint.assetName,
+          quantity: String(mint.amount)
+        };
+        const existingQuantity = Number(map.get(mintAmount.unit)) || 0;
+        map.set(
+          mintAmount.unit,
+          String(existingQuantity - Number(mintAmount.quantity))
+        );
+        return map;
+      }, requiredAssets);
+      const selectedInputs = experimentalSelectUtxos(
+        requiredAssets,
+        this.meshTxBuilderBody.extraInputs,
+        this.meshTxBuilderBody.selectionThreshold.toString()
+      );
+      selectedInputs.forEach((input) => {
+        const pubKeyTxIn = {
+          type: "PubKey",
+          txIn: {
+            txHash: input.input.txHash,
+            txIndex: input.input.outputIndex,
+            amount: input.output.amount,
+            address: input.output.address
+          }
+        };
+        this.meshTxBuilderBody.inputs.push(pubKeyTxIn);
+      });
+    };
+    this.removeDuplicateInputs = () => {
+      const { inputs } = this.meshTxBuilderBody;
+      const getTxInId = (txIn) => `${txIn.txHash}#${txIn.txIndex}`;
+      const currentTxInIds = [];
+      const addedInputs = [];
+      for (let i = 0; i < inputs.length; i += 1) {
+        const currentInput = inputs[i];
+        const currentTxInId = getTxInId(currentInput.txIn);
+        if (currentTxInIds.includes(currentTxInId)) {
+          inputs.splice(i, 1);
+          i -= 1;
+        } else {
+          addedInputs.push(currentInput);
+        }
+      }
+      this.meshTxBuilderBody.inputs = addedInputs;
+    };
+    this.emptyTxBuilderBody = () => {
+      this.meshTxBuilderBody = emptyTxBuilderBody();
+      return emptyTxBuilderBody;
+    };
+    this.reset = () => {
+      this.meshTxBuilderBody = emptyTxBuilderBody();
+      this.txEvaluationMultiplier = 1.1;
+      this.txOutput = void 0;
+      this.addingPlutusScriptInput = false;
+      this.plutusSpendingScriptVersion = void 0;
+      this.addingPlutusMint = false;
+      this.plutusMintingScriptVersion = void 0;
+      this.addingPlutusWithdrawal = false;
+      this.plutusWithdrawalScriptVersion = void 0;
+      this._protocolParams = DEFAULT_PROTOCOL_PARAMETERS3;
+      this.mintItem = void 0;
+      this.txInQueueItem = void 0;
+      this.withdrawalItem = void 0;
+      this.collateralQueueItem = void 0;
+      this.refScriptTxInQueueItem = void 0;
+    };
+    this.meshTxBuilderBody = emptyTxBuilderBody();
+  }
+};
+
+// src/mesh-tx-builder/index.ts
+import { CSLSerializer } from "@meshsdk/core-csl";
+var MeshTxBuilder = class extends MeshTxBuilderCore {
+  constructor({
+    serializer,
+    fetcher,
+    submitter,
+    evaluator,
+    params,
+    isHydra = false
+  } = {}) {
+    super();
+    this.txHex = "";
+    this.queriedTxHashes = /* @__PURE__ */ new Set();
+    this.queriedUTxOs = {};
+    /**
+     * It builds the transaction and query the blockchain for missing information
+     * @param customizedTx The optional customized transaction body
+     * @returns The signed transaction in hex ready to submit / signed by client
+     */
+    this.complete = async (customizedTx) => {
+      if (customizedTx) {
+        this.meshTxBuilderBody = customizedTx;
+      } else {
+        this.queueAllLastItem();
+      }
+      this.removeDuplicateInputs();
+      const { inputs, collaterals } = this.meshTxBuilderBody;
+      const incompleteTxIns = [...inputs, ...collaterals].filter(
+        (txIn) => !this.isInputComplete(txIn)
+      );
+      await this.queryAllTxInfo(incompleteTxIns);
+      incompleteTxIns.forEach((txIn) => {
+        this.completeTxInformation(txIn);
+      });
+      this.addUtxosFromSelection();
+      let txHex = this.serializer.serializeTxBody(
+        this.meshTxBuilderBody,
+        this._protocolParams
+      );
+      if (this.evaluator) {
+        const txEvaluation = await this.evaluator.evaluateTx(txHex).catch((error) => {
+          throw Error(`Tx evaluation failed: ${error}`);
+        });
+        this.updateRedeemer(this.meshTxBuilderBody, txEvaluation);
+        txHex = this.serializer.serializeTxBody(
+          this.meshTxBuilderBody,
+          this._protocolParams
+        );
+      }
+      console.log(txHex);
+      this.txHex = txHex;
+      return txHex;
+    };
+    /**
+     * It builds the transaction without dependencies
+     * @param customizedTx The optional customized transaction body
+     * @returns The signed transaction in hex ready to submit / signed by client
+     */
+    this.completeSync = (customizedTx) => {
+      if (customizedTx) {
+        this.meshTxBuilderBody = customizedTx;
+      } else {
+        this.queueAllLastItem();
+      }
+      return this.serializer.serializeTxBody(
+        this.meshTxBuilderBody,
+        this._protocolParams
+      );
+    };
+    /**
+     * Complete the signing process
+     * @returns The signed transaction in hex
+     */
+    this.completeSigning = () => {
+      const signedTxHex = this.serializer.addSigningKeys(
+        this.txHex,
+        this.meshTxBuilderBody.signingKey
+      );
+      this.txHex = signedTxHex;
+      return signedTxHex;
+    };
+    /**
+     * Submit transactions to the blockchain using the fetcher instance
+     * @param txHex The signed transaction in hex
+     * @returns
+     */
+    this.submitTx = async (txHex) => {
+      const txHash = await this.submitter?.submitTx(txHex);
+      return txHash;
+    };
+    /**
+     * Get the UTxO information from the blockchain
+     * @param TxHash The TxIn object that contains the txHash and txIndex, while missing amount and address information
+     */
+    this.getUTxOInfo = async (txHash) => {
+      let utxos = [];
+      if (!this.queriedTxHashes.has(txHash)) {
+        this.queriedTxHashes.add(txHash);
+        utxos = await this.fetcher?.fetchUTxOs(txHash) || [];
+        this.queriedUTxOs[txHash] = utxos;
+      }
+    };
+    this.queryAllTxInfo = (incompleteTxIns) => {
+      const queryUTxOPromises = [];
+      if (incompleteTxIns.length > 0 && !this.fetcher)
+        throw Error(
+          "Transaction information is incomplete while no fetcher instance is provided"
+        );
+      for (let i = 0; i < incompleteTxIns.length; i++) {
+        const currentTxIn = incompleteTxIns[i];
+        if (!this.isInputInfoComplete(currentTxIn)) {
+          queryUTxOPromises.push(this.getUTxOInfo(currentTxIn.txIn.txHash));
+        }
+        if (currentTxIn.type === "Script" && currentTxIn.scriptTxIn.scriptSource?.type === "Inline" && !this.isRefScriptInfoComplete(currentTxIn)) {
+          queryUTxOPromises.push(
+            this.getUTxOInfo(currentTxIn.scriptTxIn.scriptSource.txHash)
+          );
+        }
+      }
+      return Promise.all(queryUTxOPromises);
+    };
+    this.completeTxInformation = (input) => {
+      if (!this.isInputInfoComplete(input)) {
+        const utxos = this.queriedUTxOs[input.txIn.txHash];
+        const utxo = utxos?.find(
+          (utxo2) => utxo2.input.outputIndex === input.txIn.txIndex
+        );
+        const amount = utxo?.output.amount;
+        const address = utxo?.output.address;
+        if (!amount || amount.length === 0)
+          throw Error(
+            `Couldn't find value information for ${input.txIn.txHash}#${input.txIn.txIndex}`
+          );
+        input.txIn.amount = amount;
+        if (input.type === "PubKey") {
+          if (!address || address === "")
+            throw Error(
+              `Couldn't find address information for ${input.txIn.txHash}#${input.txIn.txIndex}`
+            );
+          input.txIn.address = address;
+        }
+      }
+      if (input.type === "Script" && input.scriptTxIn.scriptSource?.type == "Inline" && !this.isRefScriptInfoComplete(input)) {
+        const scriptSource = input.scriptTxIn.scriptSource;
+        const refUtxos = this.queriedUTxOs[scriptSource.txHash];
+        const scriptRefUtxo = refUtxos.find(
+          (utxo) => utxo.input.outputIndex === scriptSource.txIndex
+        );
+        if (!scriptRefUtxo)
+          throw Error(
+            `Couldn't find script reference utxo for ${scriptSource.txHash}#${scriptSource.txIndex}`
+          );
+        scriptSource.scriptHash = scriptRefUtxo?.output.scriptHash;
+      }
+    };
+    this.isInputComplete = (txIn) => {
+      if (txIn.type === "PubKey") return this.isInputInfoComplete(txIn);
+      if (txIn.type === "Script") {
+        return this.isInputInfoComplete(txIn) && this.isRefScriptInfoComplete(txIn);
+      }
+      return true;
+    };
+    this.isInputInfoComplete = (txIn) => {
+      const { amount, address } = txIn.txIn;
+      if (txIn.type === "PubKey" && (!amount || !address)) return false;
+      if (txIn.type === "Script") {
+        if (!amount) return false;
+      }
+      return true;
+    };
+    this.isRefScriptInfoComplete = (scriptTxIn) => {
+      const { scriptSource } = scriptTxIn.scriptTxIn;
+      if (scriptSource?.type === "Inline" && !scriptSource?.scriptHash)
+        return false;
+      return true;
+    };
+    if (serializer) {
+      this.serializer = serializer;
+    } else {
+      this.serializer = new CSLSerializer();
+    }
+    if (fetcher) this.fetcher = fetcher;
+    if (submitter) this.submitter = submitter;
+    if (evaluator) this.evaluator = evaluator;
+    if (params) this.protocolParams(params);
+    if (isHydra)
+      this.protocolParams({
+        minFeeA: 0,
+        minFeeB: 0,
+        priceMem: 0,
+        priceStep: 0,
+        collateralPercent: 0,
+        coinsPerUtxoSize: 0
+      });
+  }
+};
+
+// src/scripts/forge.script.ts
+import {
+  buildScriptPubkey,
+  deserializeEd25519KeyHash,
+  toNativeScript,
+  resolvePaymentKeyHash
+} from "@meshsdk/core-cst";
+var ForgeScript = class {
+  static withOneSignature(address) {
+    const keyHash = deserializeEd25519KeyHash(resolvePaymentKeyHash(address));
+    return buildScriptPubkey(keyHash).toCbor();
+  }
+  // static withAtLeastNSignatures(
+  //   addresses: string[], minimumRequired: number,
+  // ): string {
+  //   const nativeScripts = csl.NativeScripts.new();
+  //   addresses.forEach((address) => {
+  //     const keyHash = deserializeEd25519KeyHash(
+  //       resolvePaymentKeyHash(address),
+  //     );
+  //     nativeScripts.add(buildScriptPubkey(keyHash));
+  //   });
+  //   const scriptNOfK = csl.ScriptNOfK.new(minimumRequired, nativeScripts);
+  //   return csl.NativeScript.new_script_any(scriptNOfK).to_hex();
+  // }
+  // static withAnySignature(addresses: string[]): string {
+  //   const nativeScripts = csl.NativeScripts.new();
+  //   addresses.forEach((address) => {
+  //     const keyHash = deserializeEd25519KeyHash(
+  //       resolvePaymentKeyHash(address),
+  //     );
+  //     nativeScripts.add(buildScriptPubkey(keyHash));
+  //   });
+  //   const scriptAny = csl.ScriptAny.new(nativeScripts);
+  //   return csl.NativeScript.new_script_any(scriptAny).to_hex();
+  // }
+  // static withAllSignatures(addresses: string[]): string {
+  //   const nativeScripts = csl.NativeScripts.new();
+  //   addresses.forEach((address) => {
+  //     const keyHash = deserializeEd25519KeyHash(
+  //       resolvePaymentKeyHash(address),
+  //     );
+  //     nativeScripts.add(buildScriptPubkey(keyHash));
+  //   });
+  //   const scriptAll = csl.ScriptAll.new(nativeScripts);
+  //   return csl.NativeScript.new_script_any(scriptAll).to_hex();
+  // }
+  static fromNativeScript(script) {
+    return toNativeScript(script).toCbor();
+  }
+};
+
+// src/transaction/index.ts
+import {
+  CIP68_100,
+  CIP68_222,
+  DEFAULT_REDEEMER_BUDGET as DEFAULT_REDEEMER_BUDGET2,
+  POLICY_ID_LENGTH,
+  SUPPORTED_TOKENS,
+  hexToString,
+  metadataToCip68,
+  stringToHex
+} from "@meshsdk/common";
+import {
+  deserializeNativeScript,
+  deserializePlutusScript,
+  fromScriptRef
+} from "@meshsdk/core-cst";
+var Transaction = class {
+  constructor(options) {
+    this.isCollateralNeeded = false;
+    this.txBuilder = new MeshTxBuilder(options);
+    this.initiator = options.initiator;
+  }
+  /**
+   * Adds an output to the transaction.
+   *
+   * @param recipient The recipient of the output.
+   * @param assets The assets to send. Provide string for lovelace and Asset[] for tokens and/or lovelace.
+   * @returns The transaction builder.
+   * @see {@link https://meshjs.dev/apis/transaction#sendAssets}
+   */
+  sendAssets(recipient, assets) {
+    if (typeof assets === "string") {
+      assets = [
+        {
+          unit: "lovelace",
+          quantity: assets
+        }
+      ];
+    }
+    if (typeof recipient === "string") {
+      this.txBuilder.txOut(recipient, assets);
+    }
+    if (typeof recipient === "object") {
+      this.txBuilder.txOut(recipient.address, assets);
+      if (recipient.datum) {
+        if (recipient.datum.inline) {
+          this.txBuilder.txOutInlineDatumValue(recipient.datum.value);
+        } else {
+          this.txBuilder.txOutDatumHashValue(recipient.datum.value);
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Suggest deprecated - Adds a transaction output to the transaction.
+   * Use sendAssets instead:
+   * ```ts
+   * this.sendAssets(recipient, lovelace);
+   * ```
+   *
+   * Deprecation reason - Unnecessary implementation which might cause confusion.
+   *
+   * @param {Recipient} recipient The recipient of the transaction.
+   * @param {string} lovelace The amount of lovelace to send.
+   * @returns {Transaction} The Transaction object.
+   * @see {@link https://meshjs.dev/apis/transaction#sendAda}
+   */
+  sendLovelace(recipient, lovelace) {
+    return this.sendAssets(recipient, lovelace);
+  }
+  /**
+   * Suggest deprecated - Adds stable coins transaction output to the transaction.
+   * Please use sendAssets with helper function to obtain token unit instead:
+   * ```ts
+   * const assets = [{ unit: SUPPORTED_TOKENS.GIMBAL, quantity: "100" }]
+   * transaction.sendAssets(recipient, assets)
+   * ```
+   *
+   * Deprecation reason - Required maintenance on tokens.
+   *
+   * @param {Recipient} recipient The recipient of the transaction.
+   * @param {Token} ticker The ticker of the token to send.
+   * @param {string} amount The amount of the token to send.
+   * @returns {Transaction} The Transaction object.
+   * @see {@link https://meshjs.dev/apis/transaction#sendToken}
+   */
+  sendToken(recipient, ticker, amount) {
+    const assets = [{ unit: SUPPORTED_TOKENS[ticker], quantity: amount }];
+    return this.sendAssets(recipient, assets);
+  }
+  /**
+   * Adds an output to the transaction.
+   * Suggest deprecated - use sendAssets instead:
+   *
+   * ```ts
+   * const assets = value.output.amount;
+   * this.sendAssets(recipient, assets);
+   * ```
+   * Deprecation reason - Unnecessary implementation which might cause confusion.
+   *
+   * @param {Recipient} recipient The recipient of the output.
+   * @param {UTxO} value The UTxO value of the output.
+   * @returns {Transaction} The Transaction object.
+   */
+  sendValue(recipient, value) {
+    const assets = value.output.amount;
+    return this.sendAssets(recipient, assets);
+  }
+  /**
+   * Sets the inputs for the transaction.
+   *
+   * @param {UTxO[]} inputs The inputs to set.
+   * @returns {Transaction} The transaction.
+   */
+  setTxInputs(inputs) {
+    inputs.forEach((input) => {
+      this.txBuilder.txIn(
+        input.input.txHash,
+        input.input.outputIndex,
+        input.output.amount,
+        input.output.address
+      );
+    });
+    return this;
+  }
+  /**
+   * Sets the reference inputs for the transaction.
+   *
+   * @param {UTxO[]} inputs The reference inputs to set.
+   * @returns {Transaction} The transaction.
+   */
+  setTxRefInputs(inputs) {
+    inputs.forEach((input) => {
+      this.txBuilder.readOnlyTxInReference(
+        input.input.txHash,
+        input.input.outputIndex
+      );
+    });
+    return this;
+  }
+  /**
+   * Sets the native script for the transaction.
+   * @param {NativeScript} script The native script to spend from.
+   * @param {UTxO} utxo The UTxO attached to the script.
+   * @returns {Transaction} The Transaction object.
+   */
+  setNativeScriptInput(script, utxo) {
+    const { scriptCbor } = this.txBuilder.serializer.deserializer.script.deserializeNativeScript(
+      script
+    );
+    this.txBuilder.txIn(
+      utxo.input.txHash,
+      utxo.input.outputIndex,
+      utxo.output.amount,
+      utxo.output.address
+    ).txInScript(scriptCbor);
+    return this;
+  }
+  // TODO: nuke this probably as the input type is too confusing
+  redeemValue(options) {
+    const { value, script, datum, redeemer } = options;
+    const red = redeemer || {
+      data: { alternative: 0, fields: ["mesh"] },
+      budget: DEFAULT_REDEEMER_BUDGET2
+    };
+    if ("code" in script) {
+      this.isCollateralNeeded = true;
+      this.spendingPlutusScript(script).txIn(
+        value.input.txHash,
+        value.input.outputIndex,
+        value.output.amount,
+        value.output.address
+      ).txInScript(script.code).txInRedeemerValue(red.data, "Mesh", red.budget);
+    }
+    if ("output" in script) {
+      if (!script.output.scriptRef) {
+        throw new Error("redeemValue: No script reference found in UTxO");
+      }
+      const scriptRef = fromScriptRef(script.output.scriptRef);
+      if (!scriptRef || !("code" in scriptRef)) {
+        throw new Error("redeemValue: Script reference not found");
+      }
+      this.isCollateralNeeded = true;
+      this.spendingPlutusScript(scriptRef).txIn(
+        value.input.txHash,
+        value.input.outputIndex,
+        value.output.amount,
+        value.output.address
+      ).spendingTxInReference(
+        script.input.txHash,
+        script.input.outputIndex,
+        script.output.scriptHash
+      ).txInRedeemerValue(red.data, "Mesh", red.budget);
+    }
+    if (datum) {
+      this.txBuilder.txInDatumValue(datum);
+    } else {
+      this.txBuilder.txInInlineDatumPresent();
+    }
+    return this;
+  }
+  // TODO: nuke this probably as the input type is too confusing
+  mintAsset(forgeScript, mint, redeemer) {
+    const assetQuantity = mint.assetQuantity;
+    let assetNameHex = stringToHex(mint.assetName);
+    const referenceAssetNameHex = CIP68_100(assetNameHex);
+    if (mint.cip68ScriptAddress) {
+      assetNameHex = CIP68_222(assetNameHex);
+    }
+    let policyId = "";
+    switch (typeof forgeScript) {
+      case "string":
+        policyId = deserializeNativeScript(forgeScript).hash().toString();
+        this.txBuilder.mint(assetQuantity, policyId, assetNameHex).mintingScript(forgeScript);
+        if (mint.cip68ScriptAddress) {
+          this.txBuilder.mint(assetQuantity, policyId, referenceAssetNameHex).mintingScript(forgeScript);
+        }
+        break;
+      case "object":
+        if (!redeemer)
+          throw new Error(
+            "burnAsset: Redeemer data is required for Plutus minting"
+          );
+        if ("code" in forgeScript) {
+          policyId = deserializePlutusScript(
+            forgeScript.code,
+            forgeScript.version
+          ).hash().toString();
+          this.isCollateralNeeded = true;
+          this.mintPlutusScript(forgeScript).mint(assetQuantity, policyId, assetNameHex).mintingScript(forgeScript.code).mintRedeemerValue(redeemer.data, "Mesh", redeemer.budget);
+          if (mint.cip68ScriptAddress) {
+            this.mintPlutusScript(forgeScript).mint(assetQuantity, policyId, referenceAssetNameHex).mintingScript(forgeScript.code).mintRedeemerValue(redeemer.data, "Mesh", redeemer.budget);
+          }
+          break;
+        }
+        if ("output" in forgeScript) {
+          if (!forgeScript.output.scriptRef) {
+            throw new Error("mintAsset: No script reference found in UTxO");
+          }
+          const script = fromScriptRef(forgeScript.output.scriptRef);
+          if (!script) {
+            throw new Error("mintAsset: Script reference not found");
+          }
+          if ("code" in script) {
+            policyId = deserializePlutusScript(script.code, script.version).hash().toString();
+            this.isCollateralNeeded = true;
+            this.mintPlutusScript(script).mint(assetQuantity, policyId, assetNameHex).mintTxInReference(
+              forgeScript.input.txHash,
+              forgeScript.input.outputIndex
+            ).mintRedeemerValue(redeemer.data, "Mesh", redeemer.budget);
+            if (mint.cip68ScriptAddress) {
+              this.mintPlutusScript(script).mint(assetQuantity, policyId, referenceAssetNameHex).mintTxInReference(
+                forgeScript.input.txHash,
+                forgeScript.input.outputIndex
+              ).mintRedeemerValue(redeemer.data, "Mesh", redeemer.budget);
+              break;
+            }
+            break;
+          } else {
+            throw new Error(
+              "mintAsset: Reference script minting not implemented"
+            );
+          }
+        }
+        break;
+    }
+    if (mint.metadata && mint.label) {
+      this.setMetadata(Number(mint.label), {
+        [policyId]: {
+          [mint.assetName]: mint.metadata
+        },
+        version: 1
+      });
+    }
+    if (mint.recipient) {
+      this.sendAssets(mint.recipient, [
+        { unit: policyId + assetNameHex, quantity: mint.assetQuantity }
+      ]);
+    }
+    if (mint.cip68ScriptAddress) {
+      this.sendAssets(
+        {
+          address: mint.cip68ScriptAddress,
+          datum: { inline: true, value: metadataToCip68(mint.metadata) }
+        },
+        [
+          {
+            unit: policyId + referenceAssetNameHex,
+            quantity: mint.assetQuantity
+          }
+        ]
+      );
+    }
+    return this;
+  }
+  // TODO: nuke this probably as the input type is too confusing
+  // TO be deprecated as it doesnt support reference script minting native assets
+  burnAsset(forgeScript, asset, redeemer) {
+    const assetQuantity = "-" + asset.quantity;
+    const mint = {
+      assetName: hexToString(asset.unit.slice(POLICY_ID_LENGTH)),
+      assetQuantity
+    };
+    try {
+      this.mintAsset(forgeScript, mint, redeemer);
+    } catch (error) {
+      throw new Error("burnAsset: " + error);
+    }
+    return this;
+  }
+  /**
+   * Sets the change address for the transaction.
+   *
+   * @param {string} changeAddress The change address.
+   * @returns {Transaction} The Transaction object.
+   */
+  setChangeAddress(changeAddress) {
+    this.txBuilder.changeAddress(changeAddress);
+    return this;
+  }
+  /**
+   * Sets the collateral for the transaction.
+   *
+   * @param {UTxO[]} collateral - Set the UTxO for collateral.
+   * @returns {Transaction} The Transaction object.
+   */
+  setCollateral(collateral) {
+    collateral.forEach((collateralUtxo) => {
+      this.txBuilder.txInCollateral(
+        collateralUtxo.input.txHash,
+        collateralUtxo.input.outputIndex,
+        collateralUtxo.output.amount,
+        collateralUtxo.output.address
+      );
+    });
+    return this;
+  }
+  /**
+   * Sets the required signers for the transaction.
+   *
+   * @param {string[]} addresses The addresses of the required signers.
+   * @returns {Transaction} The Transaction object.
+   */
+  setRequiredSigners(addresses) {
+    addresses.forEach((address) => {
+      const { pubKeyHash } = this.txBuilder.serializer.deserializer.key.deserializeAddress(address);
+      this.txBuilder.requiredSignerHash(pubKeyHash);
+    });
+    return this;
+  }
+  /**
+   * Set the time to live for the transaction.
+   *
+   * @param {string} slot The slot number to expire the transaction at.
+   * @returns {Transaction} The Transaction object.
+   * @see {@link https://meshjs.dev/apis/transaction#setTimeLimit}
+   */
+  setTimeToExpire(slot) {
+    this.txBuilder.invalidHereafter(Number(slot));
+    return this;
+  }
+  /**
+   * Sets the start slot for the transaction.
+   *
+   * @param {string} slot The start slot for the transaction.
+   * @returns {Transaction} The Transaction object.
+   * @see {@link https://meshjs.dev/apis/transaction#setTimeLimit}
+   */
+  setTimeToStart(slot) {
+    this.txBuilder.invalidBefore(Number(slot));
+    return this;
+  }
+  /**
+   * Add a JSON metadata entry to the transaction.
+   *
+   * @param {number} key The key to use for the metadata entry.
+   * @param {unknown} value The value to use for the metadata entry.
+   * @returns {Transaction} The Transaction object.
+   * @see {@link https://meshjs.dev/apis/transaction#setMetadata}
+   */
+  setMetadata(key, value) {
+    this.txBuilder.metadataValue(key.toString(), value);
+    return this;
+  }
+  withdrawRewards(rewardAddress, lovelace) {
+    this.txBuilder.withdrawal(rewardAddress, lovelace);
+    return this;
+  }
+  delegateStake(rewardAddress, poolId) {
+    this.txBuilder.delegateStakeCertificate(
+      this.txBuilder.serializer.resolver.keys.resolveStakeKeyHash(
+        rewardAddress
+      ),
+      this.txBuilder.serializer.resolver.keys.resolveEd25519KeyHash(poolId)
+    );
+    return this;
+  }
+  deregisterStake(rewardAddress) {
+    this.txBuilder.deregisterStakeCertificate(
+      this.txBuilder.serializer.resolver.keys.resolveStakeKeyHash(rewardAddress)
+    );
+    return this;
+  }
+  registerStake(rewardAddress) {
+    this.txBuilder.registerStakeCertificate(
+      this.txBuilder.serializer.resolver.keys.resolveStakeKeyHash(rewardAddress)
+    );
+    return this;
+  }
+  // TODO: test
+  registerPool(params) {
+    this.txBuilder.registerPoolCertificate(params);
+    return this;
+  }
+  // TODO: test
+  retirePool(poolId, epochNo) {
+    this.txBuilder.retirePoolCertificate(poolId, epochNo);
+    return this;
+  }
+  async build() {
+    try {
+      await this.addCollateralIfNeeded();
+      await this.addTxInputsAsNeeded();
+      await this.addChangeAddress();
+      return this.txBuilder.complete();
+    } catch (error) {
+      throw new Error(
+        `[Transaction] An error occurred during build: ${error}.`
+      );
+    }
+  }
+  mintPlutusScript(script) {
+    switch (script.version) {
+      case "V1":
+        this.txBuilder.mintPlutusScriptV1();
+        break;
+      case "V2":
+        this.txBuilder.mintPlutusScriptV2();
+        break;
+      case "V3":
+        this.txBuilder.mintPlutusScriptV3();
+        break;
+    }
+    return this.txBuilder;
+  }
+  spendingPlutusScript(script) {
+    switch (script.version) {
+      case "V1":
+        this.txBuilder.spendingPlutusScriptV1();
+        break;
+      case "V2":
+        this.txBuilder.spendingPlutusScriptV2();
+        break;
+      case "V3":
+        this.txBuilder.spendingPlutusScriptV3();
+        break;
+    }
+    return this.txBuilder;
+  }
+  async addCollateralIfNeeded() {
+    if (this.isCollateralNeeded) {
+      const collaterals = await this.initiator.getCollateral();
+      this.setCollateral(collaterals);
+    }
+  }
+  async addTxInputsAsNeeded() {
+    const utxos = await this.initiator.getUtxos();
+    this.txBuilder.selectUtxosFrom(utxos);
+  }
+  async addChangeAddress() {
+    if (this.txBuilder.meshTxBuilderBody.changeAddress === "") {
+      const changeAddress = await this.initiator.getChangeAddress();
+      this.setChangeAddress(changeAddress);
+    }
+  }
+};
+export {
+  ForgeScript,
+  MeshTxBuilder,
+  Transaction,
+  UtxoSelection,
+  experimentalSelectUtxos,
+  keepRelevant,
+  largestFirst,
+  largestFirstMultiAsset
+};