@meshsdk/common 1.9.0-beta.10 → 1.9.0-beta.100

package/dist/index.cjs

@@ -34,12 +34,14 @@ __export(index_exports, {
   BigNum: () => BigNum,
   CIP68_100: () => CIP68_100,
   CIP68_222: () => CIP68_222,
+  DEFAULT_FETCHER_OPTIONS: () => DEFAULT_FETCHER_OPTIONS,
   DEFAULT_PROTOCOL_PARAMETERS: () => DEFAULT_PROTOCOL_PARAMETERS,
   DEFAULT_REDEEMER_BUDGET: () => DEFAULT_REDEEMER_BUDGET,
   DEFAULT_V1_COST_MODEL_LIST: () => DEFAULT_V1_COST_MODEL_LIST,
   DEFAULT_V2_COST_MODEL_LIST: () => DEFAULT_V2_COST_MODEL_LIST,
   DEFAULT_V3_COST_MODEL_LIST: () => DEFAULT_V3_COST_MODEL_LIST,
   DREP_DEPOSIT: () => DREP_DEPOSIT,
+  GovernanceActionKind: () => GovernanceActionKind,
   HARDENED_KEY_START: () => HARDENED_KEY_START,
   LANGUAGE_VERSIONS: () => LANGUAGE_VERSIONS,
   MeshValue: () => MeshValue,
@@ -51,7 +53,9 @@ __export(index_exports, {
   SUPPORTED_OGMIOS_LINKS: () => SUPPORTED_OGMIOS_LINKS,
   SUPPORTED_TOKENS: () => SUPPORTED_TOKENS,
   SUPPORTED_WALLETS: () => SUPPORTED_WALLETS,
+  TxTester: () => TxTester,
   UtxoSelection: () => UtxoSelection,
+  VOTING_PROPOSAL_DEPOSIT: () => VOTING_PROPOSAL_DEPOSIT,
   assetClass: () => assetClass,
   assetName: () => assetName,
   assocMap: () => assocMap,
@@ -60,11 +64,13 @@ __export(index_exports, {
   byteString: () => byteString,
   bytesToHex: () => bytesToHex,
   castProtocol: () => castProtocol,
+  cloneTxBuilderBody: () => cloneTxBuilderBody,
   conStr: () => conStr,
   conStr0: () => conStr0,
   conStr1: () => conStr1,
   conStr2: () => conStr2,
   conStr3: () => conStr3,
+  credential: () => credential,
   currencySymbol: () => currencySymbol,
   dict: () => dict,
   emptyTxBuilderBody: () => emptyTxBuilderBody,
@@ -78,8 +84,11 @@ __export(index_exports, {
   hexToBytes: () => hexToBytes,
   hexToString: () => hexToString,
   integer: () => integer,
+  isHexString: () => isHexString,
   isNetwork: () => isNetwork,
+  jsonProofToPlutusData: () => jsonProofToPlutusData,
   keepRelevant: () => keepRelevant,
+  keySignedLogic: () => keySignedLogic,
   largestFirst: () => largestFirst,
   largestFirstMultiAsset: () => largestFirstMultiAsset,
   list: () => list,
@@ -90,18 +99,21 @@ __export(index_exports, {
   mConStr1: () => mConStr1,
   mConStr2: () => mConStr2,
   mConStr3: () => mConStr3,
+  mCredential: () => mCredential,
   mMaybeStakingHash: () => mMaybeStakingHash,
   mNone: () => mNone,
   mOption: () => mOption,
   mOutputReference: () => mOutputReference,
   mPlutusBSArrayToString: () => mPlutusBSArrayToString,
   mPubKeyAddress: () => mPubKeyAddress,
+  mScript: () => mScript,
   mScriptAddress: () => mScriptAddress,
   mSome: () => mSome,
   mStringToPlutusBSArray: () => mStringToPlutusBSArray,
   mTuple: () => mTuple,
   mTxOutRef: () => mTxOutRef,
   mValue: () => mValue,
+  mVerificationKey: () => mVerificationKey,
   maybeStakingHash: () => maybeStakingHash,
   mergeAssets: () => mergeAssets,
   metadataStandardKeys: () => metadataStandardKeys,
@@ -110,6 +122,7 @@ __export(index_exports, {
   none: () => none,
   option: () => option,
   outputReference: () => outputReference,
+  pairs: () => pairs,
   parseAssetUnit: () => parseAssetUnit,
   plutusBSArrayToString: () => plutusBSArrayToString,
   policyId: () => policyId,
@@ -122,6 +135,7 @@ __export(index_exports, {
   resolveSlotNo: () => resolveSlotNo,
   resolveTxFees: () => resolveTxFees,
   royaltiesStandardKeys: () => royaltiesStandardKeys,
+  script: () => script,
   scriptAddress: () => scriptAddress,
   scriptHash: () => scriptHash,
   slotToBeginUnixTime: () => slotToBeginUnixTime,
@@ -130,13 +144,16 @@ __export(index_exports, {
   stringToHex: () => stringToHex,
   toBytes: () => toBytes,
   toUTF8: () => toUTF8,
+  tokenMintedLogic: () => tokenMintedLogic,
   tokenName: () => tokenName,
   tuple: () => tuple,
   txInToUtxo: () => txInToUtxo,
   txOutRef: () => txOutRef,
   unixTimeToEnclosingSlot: () => unixTimeToEnclosingSlot,
+  validityRangeFromObj: () => validityRangeFromObj,
   validityRangeToObj: () => validityRangeToObj,
-  value: () => value
+  value: () => value,
+  verificationKey: () => verificationKey
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -165,6 +182,7 @@ var DEFAULT_PROTOCOL_PARAMETERS = {
   minFeeRefScriptCostPerByte: 15
 };
 var DREP_DEPOSIT = "500000000";
+var VOTING_PROPOSAL_DEPOSIT = "100000000000";
 var resolveTxFees = (txSize, minFeeA = DEFAULT_PROTOCOL_PARAMETERS.minFeeA, minFeeB = DEFAULT_PROTOCOL_PARAMETERS.minFeeB) => {
   const fees = BigInt(minFeeA) * BigInt(txSize) + BigInt(minFeeB);
   return fees.toString();
@@ -909,6 +927,12 @@ var CIP68_222 = (tokenNameHex) => {
   return `000de140${tokenNameHex}`;
 };
 
+// src/interfaces/fetcher.ts
+var DEFAULT_FETCHER_OPTIONS = {
+  maxPage: 20,
+  order: "desc"
+};
+
 // src/types/asset.ts
 var mergeAssets = (assets) => {
   const merged = [];
@@ -996,6 +1020,7 @@ var txInToUtxo = (txIn) => {
 var emptyTxBuilderBody = () => ({
   inputs: [],
   outputs: [],
+  fee: "0",
   extraInputs: [],
   collaterals: [],
   requiredSignatures: [],
@@ -1003,26 +1028,53 @@ var emptyTxBuilderBody = () => ({
   mints: [],
   changeAddress: "",
   metadata: /* @__PURE__ */ new Map(),
+  scriptMetadata: [],
   validityRange: {},
   certificates: [],
   withdrawals: [],
   votes: [],
+  proposals: [],
   signingKey: [],
-  selectionConfig: {
-    threshold: "0",
-    strategy: "experimental",
-    includeTxFees: true
-  },
   chainedTxs: [],
   inputsForEvaluation: {},
-  network: "mainnet"
+  network: "mainnet",
+  expectedNumberKeyWitnesses: 0,
+  expectedByronAddressWitnesses: []
 });
+function cloneTxBuilderBody(body) {
+  const { extraInputs, ...otherProps } = body;
+  const cloned = structuredClone(otherProps);
+  cloned.extraInputs = extraInputs;
+  return cloned;
+}
 var validityRangeToObj = (validityRange) => {
   return {
     invalidBefore: validityRange.invalidBefore ?? null,
     invalidHereafter: validityRange.invalidHereafter ?? null
   };
 };
+var validityRangeFromObj = (obj) => {
+  const validityRange = {};
+  if (obj.invalidBefore !== null && obj.invalidBefore !== void 0) {
+    validityRange.invalidBefore = Number(obj.invalidBefore);
+  }
+  if (obj.invalidHereafter !== null && obj.invalidHereafter !== void 0) {
+    validityRange.invalidHereafter = Number(obj.invalidHereafter);
+  }
+  return validityRange;
+};
+
+// src/types/governance.ts
+var GovernanceActionKind = /* @__PURE__ */ ((GovernanceActionKind2) => {
+  GovernanceActionKind2["ParameterChangeAction"] = "ParameterChangeAction";
+  GovernanceActionKind2["HardForkInitiationAction"] = "HardForkInitiationAction";
+  GovernanceActionKind2["TreasuryWithdrawalsAction"] = "TreasuryWithdrawalsAction";
+  GovernanceActionKind2["NoConfidenceAction"] = "NoConfidenceAction";
+  GovernanceActionKind2["UpdateCommitteeAction"] = "UpdateCommitteeAction";
+  GovernanceActionKind2["NewConstitutionAction"] = "NewConstitutionAction";
+  GovernanceActionKind2["InfoAction"] = "InfoAction";
+  return GovernanceActionKind2;
+})(GovernanceActionKind || {});
 
 // src/data/mesh/constructors.ts
 var mConStr = (alternative, fields) => ({
@@ -1072,7 +1124,7 @@ var mTxOutRef = (txHash, index) => {
   }
   return mConStr0([mConStr0([txHash]), index]);
 };
-var mTuple = (key, value2) => [key, value2];
+var mTuple = (...args) => args;
 var mOption = (value2) => {
   if (value2) {
     return mSome(value2);
@@ -1083,14 +1135,16 @@ var mSome = (value2) => mConStr0([value2]);
 var mNone = () => mConStr1([]);
 
 // src/data/mesh/credentials.ts
+var mVerificationKey = (bytes) => mConStr0([bytes]);
+var mScript = (bytes) => mConStr1([bytes]);
 var mMaybeStakingHash = (stakeCredential, isStakeScriptCredential = false) => {
   if (stakeCredential === "") {
     return mConStr1([]);
   }
   if (isStakeScriptCredential) {
-    return mConStr0([mConStr0([mConStr1([stakeCredential])])]);
+    return mConStr0([mConStr0([mScript(stakeCredential)])]);
   }
-  return mConStr0([mConStr0([mConStr0([stakeCredential])])]);
+  return mConStr0([mConStr0([mVerificationKey(stakeCredential)])]);
 };
 var mPubKeyAddress = (bytes, stakeCredential, isStakeScriptCredential = false) => mConStr0([
   { alternative: 0, fields: [bytes] },
@@ -1100,6 +1154,7 @@ var mScriptAddress = (bytes, stakeCredential, isStakeScriptCredential = false) =
   { alternative: 1, fields: [bytes] },
   mMaybeStakingHash(stakeCredential || "", isStakeScriptCredential)
 ]);
+var mCredential = (hash, isScriptCredential = false) => isScriptCredential ? mScript(hash) : mVerificationKey(hash);
 
 // src/data/mesh/primitives.ts
 var mBool = (b) => b ? mConStr1([]) : mConStr0([]);
@@ -1187,11 +1242,25 @@ var assocMap = (mapItems, validation = true) => ({
     return { k, v };
   })
 });
+var pairs = (mapItems, validation = true) => ({
+  map: mapItems.map(([k, v]) => {
+    if (validation) {
+      if (typeof k !== "object" || typeof v !== "object") {
+        throw new Error(
+          `Map item of JSON Cardano data type must be an object - ${k}, ${v}`
+        );
+      }
+    }
+    return { k, v };
+  })
+});
 
 // src/data/json/aliases.ts
 var hashByteString = (bytes) => {
   if (bytes.length !== 56) {
-    throw new Error(`Invalid hash for [${bytes}] - should be 56 bytes long`);
+    throw new Error(
+      `Invalid hash for [${bytes}] - should be 28 bytes (56 hex length) long`
+    );
   }
   return byteString(bytes);
 };
@@ -1200,7 +1269,7 @@ var pubKeyHash = (bytes) => hashByteString(bytes);
 var policyId = (bytes) => {
   if (bytes.length !== POLICY_ID_LENGTH && bytes !== "") {
     throw new Error(
-      `Invalid policy id for [${bytes}] - should be ${POLICY_ID_LENGTH} bytes long or empty string for lovelace`
+      `Invalid policy id for [${bytes}] - should be ${POLICY_ID_LENGTH / 2} bytes (${POLICY_ID_LENGTH} hex length) long or empty string for lovelace`
     );
   }
   return byteString(bytes);
@@ -1232,7 +1301,9 @@ var posixTime = (int) => ({ int });
 var dict = (itemsMap) => ({
   map: itemsMap.map(([k, v]) => ({ k, v }))
 });
-var tuple = (key, value2) => ({ list: [key, value2] });
+var tuple = (...args) => ({
+  list: args
+});
 var option = (value2) => {
   if (!value2) {
     return none();
@@ -1243,32 +1314,62 @@ var some = (value2) => conStr0([value2]);
 var none = () => conStr1([]);
 
 // src/data/json/credentials.ts
+var verificationKey = (bytes) => conStr0([pubKeyHash(bytes)]);
+var script = (bytes) => conStr1([scriptHash(bytes)]);
 var maybeStakingHash = (stakeCredential, isStakeScriptCredential = false) => {
   if (stakeCredential === "") {
     return conStr1([]);
   }
   if (isStakeScriptCredential) {
-    return conStr0([
-      conStr0([conStr1([scriptHash(stakeCredential)])])
-    ]);
+    return conStr0([conStr0([script(stakeCredential)])]);
   }
-  return conStr0([
-    conStr0([conStr0([pubKeyHash(stakeCredential)])])
-  ]);
+  return conStr0([conStr0([verificationKey(stakeCredential)])]);
 };
 var pubKeyAddress = (bytes, stakeCredential, isStakeScriptCredential = false) => conStr0([
   conStr0([pubKeyHash(bytes)]),
   maybeStakingHash(stakeCredential || "", isStakeScriptCredential)
 ]);
 var scriptAddress = (bytes, stakeCredential, isStakeScriptCredential = false) => conStr0([
-  conStr1([scriptHash(bytes)]),
+  script(bytes),
   maybeStakingHash(stakeCredential || "", isStakeScriptCredential)
 ]);
+var credential = (hash, isScriptCredential = false) => isScriptCredential ? script(hash) : verificationKey(hash);
+
+// src/data/json/mpf.ts
+var jsonProofToPlutusData = (proof) => {
+  const proofSteps = [];
+  const proofJson = proof;
+  proofJson.forEach((proof2) => {
+    const skip = integer(proof2.skip);
+    switch (proof2.type) {
+      case "branch":
+        proofSteps.push(
+          conStr0([skip, byteString(proof2.neighbors.toString("hex"))])
+        );
+        break;
+      case "fork":
+        const { prefix, nibble, root } = proof2.neighbor;
+        const neighbor = conStr0([
+          integer(nibble),
+          byteString(prefix.toString("hex")),
+          byteString(root.toString("hex"))
+        ]);
+        proofSteps.push(conStr1([skip, neighbor]));
+        break;
+      case "leaf":
+        const { key, value: value2 } = proof2.neighbor;
+        proofSteps.push(conStr2([skip, byteString(key), byteString(value2)]));
+        break;
+    }
+  });
+  return proofSteps;
+};
 
 // src/data/parser.ts
 var bytesToHex = (bytes) => Buffer.from(bytes).toString("hex");
 var hexToBytes = (hex) => Buffer.from(hex, "hex");
 var stringToHex = (str) => Buffer.from(str, "utf8").toString("hex");
+var isHexString = (hex) => /^[0-9A-F]*$/i.test(hex);
 var hexToString = (hex) => Buffer.from(hex, "hex").toString("utf8");
 var toBytes = (hex) => {
   if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex))
@@ -1449,8 +1550,8 @@ var BigNum = class _BigNum {
 // src/utils/data-hash.ts
 var import_blakejs = require("blakejs");
 var hashDrepAnchor = (jsonLD) => {
-  const jsonHash = (0, import_blakejs.blake2bHex)(JSON.stringify(jsonLD, null, 2), void 0, 32);
-  return jsonHash;
+  const jsonHash = (0, import_blakejs.blake2b)(JSON.stringify(jsonLD, null, 2), void 0, 32);
+  return Buffer.from(jsonHash).toString("hex");
 };
 
 // src/utils/file.ts
@@ -1462,6 +1563,7 @@ function getFile(url) {
 }
 
 // src/data/value.ts
+var compareByteOrder = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 var value = (assets) => {
   return MeshValue.fromAssets(assets).toJSON();
 };
@@ -1473,6 +1575,26 @@ var MeshValue = class _MeshValue {
   constructor(value2 = {}) {
     this.value = value2;
   }
+  /**
+   * Sort a Value (JSON representation) by policy ID then token name
+   * @param plutusValue The Value to sort
+   * @returns Sorted Value
+   */
+  static sortValue = (plutusValue) => {
+    const sortedPolicies = [...plutusValue.map].sort(
+      (a, b) => compareByteOrder(a.k.bytes, b.k.bytes)
+    );
+    const sortedMap = sortedPolicies.map((policyEntry) => {
+      const sortedTokens = [...policyEntry.v.map].sort(
+        (a, b) => compareByteOrder(a.k.bytes, b.k.bytes)
+      );
+      return {
+        k: policyEntry.k,
+        v: { map: sortedTokens }
+      };
+    });
+    return { map: sortedMap };
+  };
   /**
    * Converting assets into MeshValue
    * @param assets The assets to convert
@@ -1563,6 +1685,23 @@ var MeshValue = class _MeshValue {
   get = (unit) => {
     return this.value[unit] ? BigInt(this.value[unit]) : BigInt(0);
   };
+  /**
+   * Get all assets that belong to a specific policy ID
+   * @param policyId The policy ID to filter by
+   * @returns Array of assets that match the policy ID
+   */
+  getPolicyAssets = (policyId2) => {
+    const assets = [];
+    Object.entries(this.value).forEach(([unit, quantity]) => {
+      if (unit.startsWith(policyId2)) {
+        assets.push({
+          unit,
+          quantity: quantity.toString()
+        });
+      }
+    });
+    return assets;
+  };
   /**
    * Get all asset units
    * @returns The asset units
@@ -1610,6 +1749,26 @@ var MeshValue = class _MeshValue {
     }
     return BigInt(this.value[unit]) <= BigInt(other.value[unit]);
   };
+  /**
+   * Check if the value is equal to another value
+   * @param other - The value to compare against
+   * @returns boolean
+   */
+  eq = (other) => {
+    return Object.keys(this.value).every((key) => this.eqUnit(key, other));
+  };
+  /**
+   * Check if the specific unit of value is equal to that unit of another value
+   * @param unit - The unit to compare
+   * @param other - The value to compare against
+   * @returns boolean
+   */
+  eqUnit = (unit, other) => {
+    if (this.value[unit] === void 0 || other.value[unit] === void 0) {
+      return false;
+    }
+    return BigInt(this.value[unit]) === BigInt(other.value[unit]);
+  };
   /**
    * Check if the value is empty
    * @returns boolean
@@ -1644,17 +1803,18 @@ var MeshValue = class _MeshValue {
   };
   /**
    * Convert the MeshValue object into Cardano data Value in Mesh Data type
+   * Entries are sorted by byte ordering of policy ID, then token name
    */
   toData = () => {
-    const valueMap = /* @__PURE__ */ new Map();
+    const unsortedMap = /* @__PURE__ */ new Map();
     this.toAssets().forEach((asset) => {
       const sanitizedName = asset.unit.replace("lovelace", "");
       const policy = sanitizedName.slice(0, 56) || "";
       const token = sanitizedName.slice(56) || "";
-      if (!valueMap.has(policy)) {
-        valueMap.set(policy, /* @__PURE__ */ new Map());
+      if (!unsortedMap.has(policy)) {
+        unsortedMap.set(policy, /* @__PURE__ */ new Map());
       }
-      const tokenMap = valueMap.get(policy);
+      const tokenMap = unsortedMap.get(policy);
       const quantity = tokenMap?.get(token);
       if (!quantity) {
         tokenMap.set(token, BigInt(asset.quantity));
@@ -1662,10 +1822,24 @@ var MeshValue = class _MeshValue {
         tokenMap.set(token, quantity + BigInt(asset.quantity));
       }
     });
+    const sortedPolicies = Array.from(unsortedMap.keys()).sort(compareByteOrder);
+    const valueMap = /* @__PURE__ */ new Map();
+    sortedPolicies.forEach((policy) => {
+      const unsortedTokenMap = unsortedMap.get(policy);
+      const sortedTokens = Array.from(unsortedTokenMap.keys()).sort(
+        compareByteOrder
+      );
+      const sortedTokenMap = /* @__PURE__ */ new Map();
+      sortedTokens.forEach((token) => {
+        sortedTokenMap.set(token, unsortedTokenMap.get(token));
+      });
+      valueMap.set(policy, sortedTokenMap);
+    });
     return valueMap;
   };
   /**
    * Convert the MeshValue object into a JSON representation of Cardano data Value
+   * Entries are sorted by byte ordering of policy ID, then token name
    * @returns Cardano data Value in JSON
    */
   toJSON = () => {
@@ -1684,11 +1858,16 @@ var MeshValue = class _MeshValue {
         valueMap[policy][token] += Number(asset.quantity);
       }
     });
-    Object.keys(valueMap).forEach((policy) => {
+    const sortedPolicies = Object.keys(valueMap).sort(compareByteOrder);
+    sortedPolicies.forEach((policy) => {
       const policyByte = currencySymbol(policy);
-      const tokens = Object.keys(valueMap[policy]).map(
-        (name) => [tokenName(name), integer(valueMap[policy][name])]
+      const sortedTokenNames = Object.keys(valueMap[policy]).sort(
+        compareByteOrder
       );
+      const tokens = sortedTokenNames.map((name) => [
+        tokenName(name),
+        integer(valueMap[policy][name])
+      ]);
       const policyMap = assocMap(tokens);
       valueMapToParse.push([policyByte, policyMap]);
     });
@@ -1712,7 +1891,7 @@ var experimentalSelectUtxos = (requiredAssets, inputs, threshold) => {
   const selectedInputs = /* @__PURE__ */ new Set();
   const onlyLovelace = /* @__PURE__ */ new Set();
   const singletons = /* @__PURE__ */ new Set();
-  const pairs = /* @__PURE__ */ new Set();
+  const pairs2 = /* @__PURE__ */ new Set();
   const rest = /* @__PURE__ */ new Set();
   const collaterals = /* @__PURE__ */ new Set();
   for (let i = 0; i < inputs.length; i++) {
@@ -1731,7 +1910,7 @@ var experimentalSelectUtxos = (requiredAssets, inputs, threshold) => {
         break;
       }
       case 3: {
-        pairs.add(i);
+        pairs2.add(i);
         break;
       }
       default: {
@@ -1764,10 +1943,10 @@ var experimentalSelectUtxos = (requiredAssets, inputs, threshold) => {
       if (!assetRequired || Number(assetRequired) <= 0) break;
       addUtxoWithAssetAmount(inputIndex, assetUnit, singletons);
     }
-    for (const inputIndex of pairs) {
+    for (const inputIndex of pairs2) {
       const assetRequired = totalRequiredAssets.get(assetUnit);
       if (!assetRequired || Number(assetRequired) <= 0) break;
-      addUtxoWithAssetAmount(inputIndex, assetUnit, pairs);
+      addUtxoWithAssetAmount(inputIndex, assetUnit, pairs2);
     }
     for (const inputIndex of rest) {
       const assetRequired = totalRequiredAssets.get(assetUnit);
@@ -1785,10 +1964,10 @@ var experimentalSelectUtxos = (requiredAssets, inputs, threshold) => {
     if (!assetRequired || Number(assetRequired) <= 0) break;
     addUtxoWithAssetAmount(inputIndex, "lovelace", singletons);
   }
-  for (const inputIndex of pairs) {
+  for (const inputIndex of pairs2) {
     const assetRequired = totalRequiredAssets.get("lovelace");
     if (!assetRequired || Number(assetRequired) <= 0) break;
-    addUtxoWithAssetAmount(inputIndex, "lovelace", pairs);
+    addUtxoWithAssetAmount(inputIndex, "lovelace", pairs2);
   }
   for (const inputIndex of rest) {
     const assetRequired = totalRequiredAssets.get("lovelace");
@@ -1963,6 +2142,473 @@ var UtxoSelection = class {
   }
 };
 
+// src/tx-tester/index.ts
+var TxTester = class {
+  txBody;
+  inputsEvaluating;
+  outputsEvaluating;
+  traces;
+  /**
+   * Create a new TxTester instance
+   * @param txBody The transaction builder body
+   */
+  constructor(txBody) {
+    this.txBody = { ...txBody };
+    this.inputsEvaluating = [];
+    this.outputsEvaluating = [];
+    this.traces = [];
+  }
+  /**
+   * Add a trace to the TxTester
+   * @param funcName The function name where the error occurred
+   * @param message The error message
+   */
+  addTrace(funcName, message) {
+    const msg = `[Error - ${funcName}]: ${message}`;
+    this.traces.push(msg);
+  }
+  /**
+   * Check if the transaction evaluation was successful
+   * @returns true if there are no errors, false otherwise
+   */
+  success() {
+    return this.traces.length === 0;
+  }
+  /**
+   * Get the error messages if any
+   * @returns A string representation of the errors or "No errors" if there are none
+   */
+  errors() {
+    if (this.traces.length > 0) {
+      return `${this.traces}`;
+    } else {
+      return "No errors";
+    }
+  }
+  /**
+   * Checks if the transaction is valid after a specified timestamp.
+   * @param requiredTimestamp The timestamp after which the transaction should be valid
+   * @returns The TxTester instance for chaining
+   */
+  validAfter = (requiredTimestamp) => {
+    const invalidBefore = this.txBody.validityRange?.invalidHereafter ? this.txBody.validityRange.invalidHereafter : 9999999999999;
+    const isValidAfter = this.txBody.validityRange?.invalidBefore ? this.txBody.validityRange.invalidBefore < requiredTimestamp : true;
+    if (!isValidAfter) {
+      this.addTrace(
+        "validAfter",
+        `tx invalid before ${invalidBefore}, with requiredTimestamp ${requiredTimestamp}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if the transaction is valid before a specified timestamp.
+   * @param requiredTimestamp The timestamp before which the transaction should be valid
+   * @returns The TxTester instance for chaining
+   */
+  validBefore = (requiredTimestamp) => {
+    const invalidHereafter = this.txBody.validityRange?.invalidBefore ? this.txBody.validityRange.invalidBefore : 0;
+    const isValidBefore = this.txBody.validityRange?.invalidHereafter ? this.txBody.validityRange.invalidHereafter > requiredTimestamp : true;
+    if (!isValidBefore) {
+      this.addTrace(
+        "validBefore",
+        `tx invalid after ${invalidHereafter}, with requiredTimestamp ${requiredTimestamp}`
+      );
+    }
+    return this;
+  };
+  // Extra Signatories Methods
+  /**
+   * Checks if a specific key is signed in the transaction.
+   * @param keyHash The key hash to check
+   * @returns The TxTester instance for chaining
+   */
+  keySigned = (keyHash) => {
+    const isKeySigned = keySignedLogic(this.txBody.requiredSignatures, keyHash);
+    if (!isKeySigned) {
+      this.addTrace("keySigned", `tx does not have key ${keyHash} signed`);
+    }
+    return this;
+  };
+  /**
+   * Checks if any one of the specified keys is signed in the transaction.
+   * @param keyHashes The array of key hashes to check
+   * @returns The TxTester instance for chaining
+   */
+  oneOfKeysSigned = (keyHashes) => {
+    const isOneOfKeysSigned = keyHashes.some(
+      (keyHash) => keySignedLogic(this.txBody.requiredSignatures, keyHash)
+    );
+    if (!isOneOfKeysSigned) {
+      this.addTrace(
+        "oneOfKeysSigned",
+        `tx does not have any of the keys signed: ${keyHashes.join(", ")}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if all specified keys are signed in the transaction.
+   * @param keyHashes The array of key hashes to check
+   * @returns The TxTester instance for chaining
+   */
+  allKeysSigned = (keyHashes) => {
+    const missingKeys = [];
+    const isAllKeysSigned = keyHashes.every((keyHash) => {
+      const isKeySigned = keySignedLogic(
+        this.txBody.requiredSignatures,
+        keyHash
+      );
+      if (!isKeySigned) {
+        missingKeys.push(keyHash);
+      }
+      return isKeySigned;
+    });
+    if (!isAllKeysSigned) {
+      this.addTrace(
+        "allKeysSigned",
+        `tx does not have all keys signed: ${missingKeys.join(", ")}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  tokenMinted = (policyId2, assetName2, quantity) => {
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    if (!isTokenMinted) {
+      this.addTrace(
+        "tokenMinted",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction and that it is the only mint.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  onlyTokenMinted = (policyId2, assetName2, quantity) => {
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    const isOnlyOneMint = this.txBody.mints?.length === 1;
+    if (!isTokenMinted) {
+      this.addTrace(
+        "onlyTokenMinted",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints`
+      );
+    }
+    if (!isOnlyOneMint) {
+      this.addTrace(
+        "onlyTokenMinted",
+        `Expected only one mint, but found ${this.txBody.mints?.length || 0} mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction, ensuring that it is the only mint for the given policy ID.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  policyOnlyMintedToken = (policyId2, assetName2, quantity) => {
+    const filteredMints = this.txBody.mints?.filter((token) => {
+      return token.policyId === policyId2;
+    }) || [];
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    const isOnlyOneMint = filteredMints.length === 1;
+    if (!isOnlyOneMint) {
+      this.addTrace(
+        "policyOnlyMintedToken",
+        `Expected only one mint for policy_id: ${policyId2}, but found ${filteredMints.length} mints.`
+      );
+    }
+    if (!isTokenMinted) {
+      this.addTrace(
+        "policyOnlyMintedToken",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific policy ID is burned in the transaction, ensuring that it is the only minting (i.e. burning item).
+   * @param policyId The policy ID to check
+   * @returns true if the policy is the only burn, false otherwise
+   */
+  checkPolicyOnlyBurn = (policyId2) => {
+    const filteredMints = this.txBody.mints?.filter((token) => {
+      return token.policyId === policyId2 && token.mintValue.findIndex((m) => BigInt(m.amount) > 0) >= 0;
+    }) || [];
+    return filteredMints.length === 0;
+  };
+  /**
+   * Not apply filter to inputs
+   * @returns The TxTester instance for chaining
+   */
+  allInputs = () => {
+    this.inputsEvaluating = this.txBody.inputs?.slice() || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address
+   * @param address The address to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAt = (address) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter(
+      (input) => txInToUtxo(input.txIn).output.address === address
+    ) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by unit
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsWith = (unit) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const inputValue = MeshValue.fromAssets(
+        txInToUtxo(input.txIn).output.amount
+      );
+      const quantity = inputValue.get(unit);
+      return quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by policy ID
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsWithPolicy = (policyId2) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const inputValue = MeshValue.fromAssets(
+        txInToUtxo(input.txIn).output.amount
+      );
+      const assets = inputValue.getPolicyAssets(policyId2);
+      return assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address and policy ID
+   * @param address The address to filter by
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAtWithPolicy = (address, policyId2) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      const inputValue = MeshValue.fromAssets(utxo.output.amount);
+      const assets = inputValue.getPolicyAssets(policyId2);
+      return utxo.output.address === address && assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address and unit
+   * @param address The address to filter by
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAtWith = (address, unit) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      const inputValue = MeshValue.fromAssets(utxo.output.amount);
+      const quantity = inputValue.get(unit);
+      return utxo.output.address === address && quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Check if inputs contain the expected value.
+   * *Reminder - It must be called after filtering methods for inputs*
+   * @param expectedValue The expected value
+   * @returns The TxTester instance for chaining
+   */
+  inputsValue = (expectedValue) => {
+    let value2 = new MeshValue();
+    this.inputsEvaluating.forEach((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      value2.addAssets(utxo.output.amount);
+    });
+    const isValueCorrect = value2.eq(expectedValue);
+    if (!isValueCorrect) {
+      this.addTrace(
+        "inputsValue",
+        `inputs ${JSON.stringify(this.inputsEvaluating)} have value ${JSON.stringify(value2)}, expect ${JSON.stringify(expectedValue)}`
+      );
+    }
+    return this;
+  };
+  // /**
+  //  * Check if inputs contain a specific inline datum.
+  //  * *Reminder - It must be called after filtering methods for inputs*
+  //  * @param datumCbor The datum CBOR to check
+  //  * @returns The TxTester instance for chaining
+  //  */
+  // inputsInlineDatumExist = (datumCbor: string): this => {
+  //   const inputsWithInlineDatum = this.inputsEvaluating.filter((input) => {
+  //     const utxo = txInToUtxo(input.txIn);
+  //     return utxo.output.plutusData === datumCbor;
+  //   });
+  //   if (inputsWithInlineDatum.length === 0) {
+  //     this.addTrace(
+  //       "inputsInlineDatumExist",
+  //       `No inputs with inline datum matching: ${datumCbor}`,
+  //     );
+  //   }
+  //   return this;
+  // };
+  /**
+   * Not apply filter to outputs
+   * @returns The TxTester instance for chaining
+   */
+  allOutputs = () => {
+    this.outputsEvaluating = this.txBody.outputs?.slice() || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address
+   * @param address The address to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAt = (address) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => output.address === address) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by unit
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsWith = (unit) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const quantity = outputValue.get(unit);
+      return quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by policy ID
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsWithPolicy = (policyId2) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const assets = outputValue.getPolicyAssets(policyId2);
+      return assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address and policy ID
+   * @param address The address to filter by
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAtWithPolicy = (address, policyId2) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const assets = outputValue.getPolicyAssets(policyId2);
+      return output.address === address && assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address and unit
+   * @param address The address to filter by
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAtWith = (address, unit) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const quantity = outputValue.get(unit);
+      return output.address === address && quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Check if outputs contain the expected value.
+   * *Reminder - It must be called after filtering methods for outputs*
+   * @param expectedValue The expected value
+   * @returns The TxTester instance for chaining
+   */
+  outputsValue = (expectedValue) => {
+    let value2 = new MeshValue();
+    this.outputsEvaluating.forEach((output) => {
+      value2.addAssets(output.amount);
+    });
+    const isValueCorrect = value2.eq(expectedValue);
+    if (!isValueCorrect) {
+      this.addTrace(
+        "outputsValue",
+        `tx outputs ${JSON.stringify(this.outputsEvaluating)} have value ${JSON.stringify(value2)}, expected ${JSON.stringify(expectedValue)}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Check if outputs contain a specific inline datum.
+   * *Reminder - It must be called after filtering methods for outputs*
+   * @param datumCbor The datum CBOR to check
+   * @returns The TxTester instance for chaining
+   */
+  outputsInlineDatumExist = (datumCbor) => {
+    const outputsWithInlineDatum = this.outputsEvaluating.filter((output) => {
+      if (output.datum && output.datum.type === "Inline") {
+        return output.datum.data.content === datumCbor;
+      }
+      return false;
+    });
+    if (outputsWithInlineDatum.length === 0) {
+      this.addTrace(
+        "outputs_inline_datum_exist",
+        `No outputs with inline datum matching: ${datumCbor}`
+      );
+    }
+    return this;
+  };
+};
+function keySignedLogic(requiredSignatures, keyHash) {
+  return requiredSignatures?.some((signatory) => signatory === keyHash) || false;
+}
+function tokenMintedLogic(mints, policyId2, assetName2, quantity) {
+  return mints?.some((token) => {
+    return token.policyId === policyId2 && token.mintValue.findIndex(
+      (m) => m.assetName === assetName2 && BigInt(m.amount) === BigInt(quantity)
+    ) >= 0;
+  }) || false;
+}
+
 // src/index.ts
 var import_bip39 = require("bip39");
 // Annotate the CommonJS export names for ESM import in node:
@@ -1971,12 +2617,14 @@ var import_bip39 = require("bip39");
   BigNum,
   CIP68_100,
   CIP68_222,
+  DEFAULT_FETCHER_OPTIONS,
   DEFAULT_PROTOCOL_PARAMETERS,
   DEFAULT_REDEEMER_BUDGET,
   DEFAULT_V1_COST_MODEL_LIST,
   DEFAULT_V2_COST_MODEL_LIST,
   DEFAULT_V3_COST_MODEL_LIST,
   DREP_DEPOSIT,
+  GovernanceActionKind,
   HARDENED_KEY_START,
   LANGUAGE_VERSIONS,
   MeshValue,
@@ -1988,7 +2636,9 @@ var import_bip39 = require("bip39");
   SUPPORTED_OGMIOS_LINKS,
   SUPPORTED_TOKENS,
   SUPPORTED_WALLETS,
+  TxTester,
   UtxoSelection,
+  VOTING_PROPOSAL_DEPOSIT,
   assetClass,
   assetName,
   assocMap,
@@ -1997,11 +2647,13 @@ var import_bip39 = require("bip39");
   byteString,
   bytesToHex,
   castProtocol,
+  cloneTxBuilderBody,
   conStr,
   conStr0,
   conStr1,
   conStr2,
   conStr3,
+  credential,
   currencySymbol,
   dict,
   emptyTxBuilderBody,
@@ -2015,8 +2667,11 @@ var import_bip39 = require("bip39");
   hexToBytes,
   hexToString,
   integer,
+  isHexString,
   isNetwork,
+  jsonProofToPlutusData,
   keepRelevant,
+  keySignedLogic,
   largestFirst,
   largestFirstMultiAsset,
   list,
@@ -2027,18 +2682,21 @@ var import_bip39 = require("bip39");
   mConStr1,
   mConStr2,
   mConStr3,
+  mCredential,
   mMaybeStakingHash,
   mNone,
   mOption,
   mOutputReference,
   mPlutusBSArrayToString,
   mPubKeyAddress,
+  mScript,
   mScriptAddress,
   mSome,
   mStringToPlutusBSArray,
   mTuple,
   mTxOutRef,
   mValue,
+  mVerificationKey,
   maybeStakingHash,
   mergeAssets,
   metadataStandardKeys,
@@ -2047,6 +2705,7 @@ var import_bip39 = require("bip39");
   none,
   option,
   outputReference,
+  pairs,
   parseAssetUnit,
   plutusBSArrayToString,
   policyId,
@@ -2059,6 +2718,7 @@ var import_bip39 = require("bip39");
   resolveSlotNo,
   resolveTxFees,
   royaltiesStandardKeys,
+  script,
   scriptAddress,
   scriptHash,
   slotToBeginUnixTime,
@@ -2067,11 +2727,14 @@ var import_bip39 = require("bip39");
   stringToHex,
   toBytes,
   toUTF8,
+  tokenMintedLogic,
   tokenName,
   tuple,
   txInToUtxo,
   txOutRef,
   unixTimeToEnclosingSlot,
+  validityRangeFromObj,
   validityRangeToObj,
-  value
+  value,
+  verificationKey
 });