@meshsdk/core-csl 1.9.0-beta.7 → 1.9.0-beta.70

package/dist/index.cjs

@@ -40,14 +40,19 @@ __export(index_exports, {
   applyCborEncoding: () => applyCborEncoding,
   applyParamsToScript: () => applyParamsToScript,
   baseAddressToStakeAddress: () => baseAddressToStakeAddress,
+  baseCertFromObj: () => baseCertFromObj,
   baseCertToObj: () => baseCertToObj,
   builderDataToCbor: () => builderDataToCbor,
   calculateTxHash: () => calculateTxHash,
   castDataToPlutusData: () => castDataToPlutusData,
   castRawDataToJsonString: () => castRawDataToJsonString,
+  cborToBuilderData: () => cborToBuilderData,
+  certificateFromObj: () => certificateFromObj,
   certificateToObj: () => certificateToObj,
+  collateralTxInFromObj: () => collateralTxInFromObj,
   collateralTxInToObj: () => collateralTxInToObj,
   csl: () => csl,
+  dataFromObj: () => dataFromObj,
   deserializeAddress: () => deserializeAddress,
   deserializeBech32Address: () => deserializeBech32Address,
   deserializeBip32PrivateKey: () => deserializeBip32PrivateKey,
@@ -71,23 +76,36 @@ __export(index_exports, {
   fromLovelace: () => fromLovelace,
   fromUTF8: () => fromUTF8,
   getDRepIds: () => getDRepIds,
+  getRequiredInputs: () => getRequiredInputs,
   getTransactionInputs: () => getTransactionInputs,
   getTransactionOutputs: () => getTransactionOutputs,
   getV2ScriptHash: () => getV2ScriptHash,
   keyHashToRewardAddress: () => keyHashToRewardAddress,
   meshTxBuilderBodyToObj: () => meshTxBuilderBodyToObj,
+  metadataFromObj: () => metadataFromObj,
+  mintItemFromObj: () => mintItemFromObj,
   mintItemToObj: () => mintItemToObj,
+  mintParametersFromObj: () => mintParametersFromObj,
   mintParametersObj: () => mintParametersObj,
+  nativeMintItemFromObj: () => nativeMintItemFromObj,
   nativeMintItemToObj: () => nativeMintItemToObj,
+  networkFromObj: () => networkFromObj,
+  networkToObj: () => networkToObj,
+  outputFromObj: () => outputFromObj,
   outputToObj: () => outputToObj,
   parseDatumCbor: () => parseDatumCbor,
   parseInlineDatum: () => parseInlineDatum,
+  plutusMintItemFromObj: () => plutusMintItemFromObj,
   plutusMintItemToObj: () => plutusMintItemToObj,
   poolIdBech32ToHex: () => poolIdBech32ToHex,
   poolIdHexToBech32: () => poolIdHexToBech32,
+  poolMetadataFromObj: () => poolMetadataFromObj,
   poolMetadataToObj: () => poolMetadataToObj,
+  poolParamsFromObj: () => poolParamsFromObj,
   poolParamsToObj: () => poolParamsToObj,
+  redeemerFromObj: () => redeemerFromObj,
   redeemerToObj: () => redeemerToObj,
+  relayFromObj: () => relayFromObj,
   relayToObj: () => relayToObj,
   resolveDataHash: () => resolveDataHash,
   resolveEd25519KeyHash: () => resolveEd25519KeyHash,
@@ -103,19 +121,24 @@ __export(index_exports, {
   rewardAddressToKeyHash: () => rewardAddressToKeyHash,
   scriptHashToBech32: () => scriptHashToBech32,
   scriptHashToRewardAddress: () => scriptHashToRewardAddress,
+  scriptSourceFromObj: () => scriptSourceFromObj,
   scriptSourceToObj: () => scriptSourceToObj,
+  scriptTxInParameterFromObj: () => scriptTxInParameterFromObj,
   scriptTxInParameterToObj: () => scriptTxInParameterToObj,
   serializeAddressObj: () => serializeAddressObj,
   serializePlutusAddressToBech32: () => serializePlutusAddressToBech32,
   serializePoolId: () => serializePoolId,
   serialzeAddress: () => serialzeAddress,
   signTransaction: () => signTransaction,
+  simpleScriptSourceFromObj: () => simpleScriptSourceFromObj,
   simpleScriptSourceToObj: () => simpleScriptSourceToObj,
+  simpleScriptTxInParameterFromObj: () => simpleScriptTxInParameterFromObj,
   simpleScriptTxInParameterToObj: () => simpleScriptTxInParameterToObj,
   skeyToPubKeyHash: () => skeyToPubKeyHash,
   toAddress: () => toAddress,
   toBaseAddress: () => toBaseAddress,
   toBytes: () => toBytes,
+  toCslValue: () => toCslValue,
   toEnterpriseAddress: () => toEnterpriseAddress,
   toLovelace: () => toLovelace,
   toNativeScript: () => toNativeScript,
@@ -123,10 +146,18 @@ __export(index_exports, {
   toRewardAddress: () => toRewardAddress,
   toScriptRef: () => toScriptRef,
   toUTF8: () => toUTF8,
+  txBuilderBodyFromObj: () => txBuilderBodyFromObj,
+  txInFromObj: () => txInFromObj,
+  txInParameterFromObj: () => txInParameterFromObj,
   txInParameterToObj: () => txInParameterToObj,
   txInToObj: () => txInToObj,
+  txMetadataToObj: () => txMetadataToObj,
+  utxoFromObj: () => utxoFromObj,
   utxoToObj: () => utxoToObj,
   v2ScriptToBech32: () => v2ScriptToBech32,
+  voteFromObj: () => voteFromObj,
+  voteToObj: () => voteToObj,
+  withdrawalFromObj: () => withdrawalFromObj,
   withdrawalToObj: () => withdrawalToObj
 });
 module.exports = __toCommonJS(index_exports);
@@ -135,7 +166,7 @@ module.exports = __toCommonJS(index_exports);
 var import_common2 = require("@meshsdk/common");
 
 // src/deser/csl.ts
-var csl = __toESM(require("@sidan-lab/sidan-csl-rs-nodejs"), 1);
+var csl = __toESM(require("@sidan-lab/whisky-js-nodejs"), 1);
 
 // src/deser/constants.ts
 var LANGUAGE_VERSIONS = {
@@ -231,7 +262,7 @@ var castDataToPlutusData = ({
     return csl.PlutusData.from_hex(content);
   }
   return csl.PlutusData.from_json(
-    content,
+    castRawDataToJsonString(content),
     csl.PlutusDatumSchema.DetailedSchema
   );
 };
@@ -270,6 +301,29 @@ var toNativeScript = (script) => {
       );
   }
 };
+var toCslValue = (assets) => {
+  let cslValue = void 0;
+  let multiAsset = csl.MultiAsset.new();
+  for (const asset of assets) {
+    if (asset.unit === "lovelace" || asset.unit === "") {
+      cslValue = csl.Value.new(csl.BigNum.from_str(asset.quantity));
+    } else {
+      const policyId = csl.ScriptHash.from_hex(asset.unit.slice(0, 56));
+      const assetName = csl.AssetName.new(
+        Buffer.from(asset.unit.slice(56), "hex")
+      );
+      const quantity = csl.BigNum.from_str(asset.quantity);
+      multiAsset.set_asset(policyId, assetName, quantity);
+    }
+  }
+  if (cslValue !== void 0) {
+    cslValue.set_multiasset(multiAsset);
+  } else {
+    cslValue = csl.Value.new(csl.BigNum.from_str("0"));
+    cslValue.set_multiasset(multiAsset);
+  }
+  return cslValue;
+};
 
 // src/deser/deserializer.ts
 var deserializeAddress = (address) => csl.Address.from_bytes(toBytes(address));
@@ -362,8 +416,11 @@ var resolveRewardAddress = (bech32) => {
     throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
   }
 };
-var resolveDataHash = (data) => {
-  const plutusData = toPlutusData(data);
+var resolveDataHash = (rawData, type = "Mesh") => {
+  const plutusData = castDataToPlutusData({
+    content: rawData,
+    type
+  });
   const dataHash = csl.hash_plutus_data(plutusData);
   return dataHash.to_hex();
 };
@@ -509,12 +566,12 @@ var keyHashToRewardAddress = (keyHashHex, network = 1) => {
 };
 
 // src/utils/transaction.ts
-var import_sidan_csl_rs_nodejs = require("@sidan-lab/sidan-csl-rs-nodejs");
+var import_whisky_js_nodejs = require("@sidan-lab/whisky-js-nodejs");
 
 // src/wasm.ts
 var parseWasmResult = (result) => {
   if (result.get_status() !== "success") {
-    throw new Error(result.get_data());
+    throw new Error(result.get_error());
   }
   return result.get_data();
 };
@@ -638,7 +695,7 @@ var getTransactionInputs = (txHex) => {
   return inputs;
 };
 var getTransactionOutputs = (txHex) => {
-  const outputs = (0, import_sidan_csl_rs_nodejs.js_get_tx_outs_utxo)(txHex).get_data();
+  const outputs = (0, import_whisky_js_nodejs.js_get_tx_outs_utxo)(txHex).get_data();
   const utxos = JSON.parse(outputs);
   return utxos;
 };
@@ -646,10 +703,10 @@ var getTransactionOutputs = (txHex) => {
 // src/utils/aiken.ts
 var applyParamsToScript = (rawScript, params, type = "Mesh") => {
   const cslParams = csl.JsVecString.new();
-  let paramType = csl.BuilderDataType.CBOR;
+  let paramType = "cbor";
   switch (type) {
     case "JSON":
-      paramType = csl.BuilderDataType.JSON;
+      paramType = "json";
       params.forEach((param) => {
         if (typeof param === "object") {
           cslParams.add(JSON.stringify(param));
@@ -676,7 +733,7 @@ var applyCborEncoding = (rawScript) => {
   return csl.js_apply_params_to_script(
     rawScript,
     csl.JsVecString.new(),
-    csl.BuilderDataType.CBOR
+    "cbor"
   );
 };
 
@@ -690,14 +747,68 @@ var getDRepIds = (dRepId) => {
   return result;
 };
 
+// src/utils/transaction-parser.ts
+var import_whisky_js_nodejs2 = require("@sidan-lab/whisky-js-nodejs");
+var getRequiredInputs = (transactionHex) => {
+  const result = (0, import_whisky_js_nodejs2.js_get_required_inputs_to_resolve)(transactionHex);
+  if (result.get_status() !== "success") {
+    throw new Error(`Failed to get required inputs: ${result.get_error()}`);
+  }
+  const utxosStr = JSON.parse(result.get_data());
+  return utxosStr.map((utxoStr) => {
+    const parts = utxoStr.split("#");
+    if (parts.length !== 2) {
+      throw new Error(`Invalid UTxO format: ${utxoStr}`);
+    }
+    const [txHash, outputIndex] = parts;
+    if (!txHash || !outputIndex) {
+      throw new Error(
+        `Invalid UTxO format: ${utxoStr}. Expected format is txHash#outputIndex`
+      );
+    }
+    return {
+      txHash,
+      outputIndex: parseInt(outputIndex)
+    };
+  });
+};
+
 // src/core/serializer.ts
-var import_json_bigint3 = __toESM(require("json-bigint"), 1);
-var import_common4 = require("@meshsdk/common");
+var import_json_bigint4 = __toESM(require("json-bigint"), 1);
+var import_common6 = require("@meshsdk/common");
 
-// src/core/adaptor/index.ts
+// src/parser/index.ts
+var import_whisky_js_nodejs3 = require("@sidan-lab/whisky-js-nodejs");
 var import_common3 = require("@meshsdk/common");
+var CSLParser = class {
+  resolvedUtxos;
+  txBuilderBody = (0, import_common3.emptyTxBuilderBody)();
+  txHex = "";
+  txHash = "";
+  constructor(txHex, resolvedUtxos = []) {
+    this.txHex = txHex;
+    this.txHash = calculateTxHash(txHex);
+    this.resolvedUtxos = resolvedUtxos;
+    const jsUtxos = import_whisky_js_nodejs3.JsVecString.new();
+    for (const utxo of resolvedUtxos) {
+      jsUtxos.add(JSON.stringify(utxo));
+    }
+    const wasmResult = (0, import_whisky_js_nodejs3.js_parse_tx_body)(txHex, jsUtxos);
+    if (wasmResult.get_status() !== "success") {
+      throw new Error(`CSLParser parse error: ${wasmResult.get_error()}`);
+    }
+    const txBodyJson = wasmResult.get_data();
+    console.log("txBodyJson", txBodyJson);
+    const txBodyObj = txBuilderBodyFromObj(txBodyJson);
+    console.log("txBodyObj", txBodyObj);
+    this.txBuilderBody = txBuilderBodyFromObj(txBodyJson);
+  }
+};
+
+// src/core/adaptor/toObj/index.ts
+var import_common4 = require("@meshsdk/common");
 
-// src/core/adaptor/data.ts
+// src/core/adaptor/toObj/data.ts
 var builderDataToCbor = ({ type, content }) => {
   if (type === "Mesh") {
     return toPlutusData(content).to_hex();
@@ -717,7 +828,7 @@ var redeemerToObj = (redeemer) => {
   };
 };
 
-// src/core/adaptor/script.ts
+// src/core/adaptor/toObj/script.ts
 var scriptSourceToObj = (scriptSource) => {
   if (scriptSource.type === "Provided") {
     return {
@@ -758,7 +869,7 @@ var simpleScriptSourceToObj = (scriptSource) => {
   };
 };
 
-// src/core/adaptor/certificate.ts
+// src/core/adaptor/toObj/certificate.ts
 var certificateToObj = (certificate) => {
   const baseCert = certificate.certType;
   switch (certificate.type) {
@@ -942,7 +1053,42 @@ var relayToObj = (relay) => {
   }
 };
 
-// src/core/adaptor/mint.ts
+// src/core/adaptor/toObj/metadata.ts
+var import_json_bigint2 = __toESM(require("json-bigint"), 1);
+var txMetadataToObj = (metadata) => {
+  const result = [];
+  metadata.forEach((value, key) => {
+    result.push({
+      tag: key.toString(),
+      metadata: import_json_bigint2.default.stringify(metadatumToObj(value))
+    });
+  });
+  return result;
+};
+var metadatumToObj = (metadatum) => {
+  if (typeof metadatum === "number" || typeof metadatum === "string") {
+    return metadatum;
+  } else if (typeof metadatum === "bigint") {
+    return metadatum.toString();
+  } else if (metadatum instanceof Uint8Array) {
+    return uint8ArrayToHex(metadatum);
+  } else if (metadatum instanceof Map) {
+    const result = {};
+    metadatum.forEach((value, key) => {
+      result[metadatumToObj(key)] = metadatumToObj(value);
+    });
+    return result;
+  } else if (Array.isArray(metadatum)) {
+    return metadatum.map(metadatumToObj);
+  } else {
+    throw new Error("metadatumToObj: Unsupported Metadatum type");
+  }
+};
+var uint8ArrayToHex = (bytes) => {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+
+// src/core/adaptor/toObj/mint.ts
 var mintItemToObj = (mintItem) => {
   switch (mintItem.type) {
     case "Plutus":
@@ -983,7 +1129,7 @@ var mintParametersObj = (mintItem) => {
   };
 };
 
-// src/core/adaptor/network.ts
+// src/core/adaptor/toObj/network.ts
 var networkToObj = (network) => {
   if (typeof network === "string") {
     return network;
@@ -994,7 +1140,7 @@ var networkToObj = (network) => {
   }
 };
 
-// src/core/adaptor/output.ts
+// src/core/adaptor/toObj/output.ts
 var outputToObj = (output) => {
   let datum = null;
   if (output.datum) {
@@ -1024,42 +1170,7 @@ var outputToObj = (output) => {
   };
 };
 
-// src/core/adaptor/metadata.ts
-var import_json_bigint2 = __toESM(require("json-bigint"), 1);
-var txMetadataToObj = (metadata) => {
-  const result = [];
-  metadata.forEach((value, key) => {
-    result.push({
-      tag: key.toString(),
-      metadata: import_json_bigint2.default.stringify(metadatumToObj(value))
-    });
-  });
-  return result;
-};
-var metadatumToObj = (metadatum) => {
-  if (typeof metadatum === "number" || typeof metadatum === "string") {
-    return metadatum;
-  } else if (typeof metadatum === "bigint") {
-    return metadatum.toString();
-  } else if (metadatum instanceof Uint8Array) {
-    return uint8ArrayToHex(metadatum);
-  } else if (metadatum instanceof Map) {
-    const result = {};
-    metadatum.forEach((value, key) => {
-      result[metadatumToObj(key)] = metadatumToObj(value);
-    });
-    return result;
-  } else if (Array.isArray(metadatum)) {
-    return metadatum.map(metadatumToObj);
-  } else {
-    throw new Error("metadatumToObj: Unsupported Metadatum type");
-  }
-};
-var uint8ArrayToHex = (bytes) => {
-  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-};
-
-// src/core/adaptor/txIn.ts
+// src/core/adaptor/toObj/txIn.ts
 var txInToObj = (txIn) => {
   switch (txIn.type) {
     case "PubKey":
@@ -1160,7 +1271,7 @@ var simpleScriptTxInParameterToObj = (simpleScriptTxInParameter) => {
   }
 };
 
-// src/core/adaptor/vote.ts
+// src/core/adaptor/toObj/vote.ts
 var voteToObj = (vote) => {
   if (vote.type === "BasicVote") {
     return {
@@ -1260,7 +1371,7 @@ var voteTypeToObj = (voteType) => {
   };
 };
 
-// src/core/adaptor/withdrawal.ts
+// src/core/adaptor/toObj/withdrawal.ts
 var withdrawalToObj = (withdrawal) => {
   if (withdrawal.type === "PubKeyWithdrawal") {
     return {
@@ -1304,7 +1415,7 @@ var withdrawalToObj = (withdrawal) => {
   }
 };
 
-// src/core/adaptor/utxo.ts
+// src/core/adaptor/toObj/utxo.ts
 var utxoToObj = ({
   input: { outputIndex, txHash },
   output: { address, amount, dataHash, plutusData, scriptRef, scriptHash }
@@ -1325,7 +1436,7 @@ var utxoToObj = ({
   };
 };
 
-// src/core/adaptor/index.ts
+// src/core/adaptor/toObj/index.ts
 var meshTxBuilderBodyToObj = ({
   inputs,
   outputs,
@@ -1343,16 +1454,31 @@ var meshTxBuilderBodyToObj = ({
   fee,
   network
 }) => {
+  let mintsObj = [];
+  mints.forEach((mint) => {
+    mint.mintValue.forEach((mintValue) => {
+      mintsObj.push(
+        mintItemToObj({
+          type: mint.type,
+          policyId: mint.policyId,
+          assetName: mintValue.assetName,
+          amount: mintValue.amount,
+          scriptSource: mint.scriptSource,
+          redeemer: mint.redeemer
+        })
+      );
+    });
+  });
   return {
     inputs: inputs.map(txInToObj),
     outputs: outputs.map(outputToObj),
     collaterals: collaterals.map(collateralTxInToObj),
     requiredSignatures,
     referenceInputs,
-    mints: mints.map((mint) => mintItemToObj(mint)),
+    mints: mintsObj,
     changeAddress,
     metadata: txMetadataToObj(metadata),
-    validityRange: (0, import_common3.validityRangeToObj)(validityRange),
+    validityRange: (0, import_common4.validityRangeToObj)(validityRange),
     certificates: certificates.map(certificateToObj),
     signingKey,
     withdrawals: withdrawals.map(withdrawalToObj),
@@ -1362,29 +1488,694 @@ var meshTxBuilderBodyToObj = ({
   };
 };
 
+// src/core/adaptor/fromObj/index.ts
+var import_common5 = require("@meshsdk/common");
+
+// src/core/adaptor/fromObj/data.ts
+var cborToBuilderData = (cborHex) => {
+  return {
+    type: "CBOR",
+    content: cborHex
+  };
+};
+var redeemerFromObj = (obj) => {
+  return {
+    data: cborToBuilderData(obj.data),
+    exUnits: obj.exUnits
+  };
+};
+var dataFromObj = (obj) => {
+  if (obj === null) {
+    return null;
+  }
+  if (typeof obj === "object") {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => dataFromObj(item));
+    } else if ("map" in obj) {
+      return Object.fromEntries(
+        obj.map.map((entry) => [
+          dataFromObj(entry.k),
+          dataFromObj(entry.v)
+        ])
+      );
+    } else if ("list" in obj) {
+      return obj.list.map((item) => dataFromObj(item));
+    } else if ("int" in obj) {
+      return BigInt(obj.int);
+    } else if ("bytes" in obj) {
+      return obj.bytes;
+    } else if ("constructor" in obj) {
+      return {
+        constructor: obj.constructor,
+        fields: obj.fields.map((field) => dataFromObj(field))
+      };
+    }
+  }
+  return obj;
+};
+
+// src/core/adaptor/fromObj/script.ts
+var scriptSourceFromObj = (obj) => {
+  if ("providedScriptSource" in obj) {
+    return {
+      type: "Provided",
+      script: {
+        code: obj.providedScriptSource.scriptCbor,
+        version: obj.providedScriptSource.languageVersion.toUpperCase()
+      }
+    };
+  }
+  if ("inlineScriptSource" in obj) {
+    return {
+      type: "Inline",
+      txHash: obj.inlineScriptSource.refTxIn.txHash,
+      txIndex: obj.inlineScriptSource.refTxIn.txIndex,
+      scriptHash: obj.inlineScriptSource.scriptHash || void 0,
+      version: obj.inlineScriptSource.languageVersion.toUpperCase(),
+      scriptSize: obj.inlineScriptSource.scriptSize.toString()
+    };
+  }
+  throw new Error(
+    `scriptSourceFromObj: Unknown script source format: ${JSON.stringify(obj)}`
+  );
+};
+var simpleScriptSourceFromObj = (obj) => {
+  if ("providedSimpleScriptSource" in obj) {
+    return {
+      type: "Provided",
+      scriptCode: obj.providedSimpleScriptSource.scriptCbor
+    };
+  }
+  if ("inlineSimpleScriptSource" in obj) {
+    return {
+      type: "Inline",
+      txHash: obj.inlineSimpleScriptSource.refTxIn.txHash,
+      txIndex: obj.inlineSimpleScriptSource.refTxIn.txIndex,
+      simpleScriptHash: obj.inlineSimpleScriptSource.simpleScriptHash || void 0
+    };
+  }
+  throw new Error(
+    `simpleScriptSourceFromObj: Unknown simple script source format: ${JSON.stringify(obj)}`
+  );
+};
+
+// src/core/adaptor/fromObj/certificate.ts
+var certificateFromObj = (obj) => {
+  if ("basicCertificate" in obj) {
+    return {
+      type: "BasicCertificate",
+      certType: baseCertFromObj(obj.basicCertificate)
+    };
+  } else if ("scriptCertificate" in obj) {
+    const certificate = {
+      type: "ScriptCertificate",
+      certType: baseCertFromObj(obj.scriptCertificate.cert)
+    };
+    if (obj.scriptCertificate.redeemer) {
+      certificate.redeemer = redeemerFromObj(obj.scriptCertificate.redeemer);
+    }
+    if (obj.scriptCertificate.scriptSource) {
+      certificate.scriptSource = scriptSourceFromObj(
+        obj.scriptCertificate.scriptSource
+      );
+    }
+    return certificate;
+  } else if ("simpleScriptCertificate" in obj) {
+    const certificate = {
+      type: "SimpleScriptCertificate",
+      certType: baseCertFromObj(obj.simpleScriptCertificate.cert)
+    };
+    if (obj.simpleScriptCertificate.simpleScriptSource) {
+      certificate.simpleScriptSource = simpleScriptSourceFromObj(
+        obj.simpleScriptCertificate.simpleScriptSource
+      );
+    }
+    return certificate;
+  }
+  throw new Error(
+    `certificateFromObj: Unknown certificate type in object: ${JSON.stringify(obj)}`
+  );
+};
+var baseCertFromObj = (obj) => {
+  if ("registerPool" in obj) {
+    return {
+      type: "RegisterPool",
+      poolParams: poolParamsFromObj(obj.registerPool.poolParams)
+    };
+  } else if ("registerStake" in obj) {
+    return {
+      type: "RegisterStake",
+      stakeKeyAddress: obj.registerStake.stakeKeyAddress
+    };
+  } else if ("delegateStake" in obj) {
+    return {
+      type: "DelegateStake",
+      stakeKeyAddress: obj.delegateStake.stakeKeyAddress,
+      poolId: obj.delegateStake.poolId
+    };
+  } else if ("deregisterStake" in obj) {
+    return {
+      type: "DeregisterStake",
+      stakeKeyAddress: obj.deregisterStake.stakeKeyAddress
+    };
+  } else if ("retirePool" in obj) {
+    return {
+      type: "RetirePool",
+      poolId: obj.retirePool.poolId,
+      epoch: obj.retirePool.epoch
+    };
+  } else if ("voteDelegation" in obj) {
+    return {
+      type: "VoteDelegation",
+      stakeKeyAddress: obj.voteDelegation.stakeKeyAddress,
+      drep: obj.voteDelegation.drep
+    };
+  } else if ("stakeAndVoteDelegation" in obj) {
+    return {
+      type: "StakeAndVoteDelegation",
+      stakeKeyAddress: obj.stakeAndVoteDelegation.stakeKeyAddress,
+      poolKeyHash: obj.stakeAndVoteDelegation.poolKeyHash,
+      drep: obj.stakeAndVoteDelegation.drep
+    };
+  } else if ("stakeRegistrationAndDelegation" in obj) {
+    return {
+      type: "StakeRegistrationAndDelegation",
+      stakeKeyAddress: obj.stakeRegistrationAndDelegation.stakeKeyAddress,
+      poolKeyHash: obj.stakeRegistrationAndDelegation.poolKeyHash,
+      coin: obj.stakeRegistrationAndDelegation.coin
+    };
+  } else if ("voteRegistrationAndDelegation" in obj) {
+    return {
+      type: "VoteRegistrationAndDelegation",
+      stakeKeyAddress: obj.voteRegistrationAndDelegation.stakeKeyAddress,
+      drep: obj.voteRegistrationAndDelegation.drep,
+      coin: obj.voteRegistrationAndDelegation.coin
+    };
+  } else if ("stakeVoteRegistrationAndDelegation" in obj) {
+    return {
+      type: "StakeVoteRegistrationAndDelegation",
+      stakeKeyAddress: obj.stakeVoteRegistrationAndDelegation.stakeKeyAddress,
+      poolKeyHash: obj.stakeVoteRegistrationAndDelegation.poolKeyHash,
+      drep: obj.stakeVoteRegistrationAndDelegation.drep,
+      coin: obj.stakeVoteRegistrationAndDelegation.coin
+    };
+  } else if ("committeeHotAuth" in obj) {
+    return {
+      type: "CommitteeHotAuth",
+      committeeColdKeyAddress: obj.committeeHotAuth.committeeColdKeyAddress,
+      committeeHotKeyAddress: obj.committeeHotAuth.committeeHotKeyAddress
+    };
+  } else if ("committeeColdResign" in obj) {
+    return {
+      type: "CommitteeColdResign",
+      committeeColdKeyAddress: obj.committeeColdResign.committeeColdKeyAddress,
+      anchor: obj.committeeColdResign.anchor || void 0
+    };
+  } else if ("dRepRegistration" in obj) {
+    return {
+      type: "DRepRegistration",
+      drepId: obj.dRepRegistration.drepId,
+      coin: obj.dRepRegistration.coin,
+      anchor: obj.dRepRegistration.anchor || void 0
+    };
+  } else if ("dRepDeregistration" in obj) {
+    return {
+      type: "DRepDeregistration",
+      drepId: obj.dRepDeregistration.drepId,
+      coin: obj.dRepDeregistration.coin
+    };
+  } else if ("dRepUpdate" in obj) {
+    return {
+      type: "DRepUpdate",
+      drepId: obj.dRepUpdate.drepId,
+      anchor: obj.dRepUpdate.anchor
+    };
+  }
+  throw new Error(
+    `baseCertFromObj: Unknown certificate type in object: ${JSON.stringify(obj)}`
+  );
+};
+var poolParamsFromObj = (obj) => {
+  return {
+    vrfKeyHash: obj.vrfKeyHash,
+    operator: obj.operator,
+    pledge: obj.pledge,
+    cost: obj.cost,
+    margin: obj.margin,
+    relays: obj.relays.map((relay) => relayFromObj(relay)),
+    owners: obj.owners,
+    rewardAddress: obj.rewardAddress,
+    metadata: obj.metadata ? poolMetadataFromObj(obj.metadata) : void 0
+  };
+};
+var poolMetadataFromObj = (obj) => {
+  return {
+    URL: obj.url,
+    hash: obj.metadata
+  };
+};
+var relayFromObj = (obj) => {
+  if ("singleHostAddr" in obj) {
+    return {
+      type: "SingleHostAddr",
+      IPV4: obj.singleHostAddr.ipv4,
+      IPV6: obj.singleHostAddr.ipv6,
+      port: obj.singleHostAddr.port
+    };
+  } else if ("singleHostName" in obj) {
+    return {
+      type: "SingleHostName",
+      domainName: obj.singleHostName.hostname,
+      port: obj.singleHostName.port
+    };
+  } else if ("multiHostName" in obj) {
+    return {
+      type: "MultiHostName",
+      domainName: obj.multiHostName.dnsName
+    };
+  }
+  throw new Error(
+    `relayFromObj: Unknown relay type in object: ${JSON.stringify(obj)}`
+  );
+};
+
+// src/core/adaptor/fromObj/metadata.ts
+var import_json_bigint3 = __toESM(require("json-bigint"), 1);
+var JSONBigParser = (0, import_json_bigint3.default)({
+  storeAsString: false,
+  useNativeBigInt: true,
+  alwaysParseAsBig: false
+});
+var metadataFromObj = (metadataArray) => {
+  const result = /* @__PURE__ */ new Map();
+  metadataArray.forEach((metadata) => {
+    const key = BigInt(metadata.tag);
+    const value = objToMetadatum(JSONBigParser.parse(metadata.metadata));
+    result.set(key, value);
+  });
+  return result;
+};
+var objToMetadatum = (obj) => {
+  if (typeof obj === "number") {
+    return obj;
+  } else if (typeof obj === "string") {
+    if (/^\d+$/.test(obj)) {
+      return BigInt(obj);
+    }
+    if (/^-?\d+$/.test(obj)) {
+      return BigInt(obj);
+    }
+    return obj;
+  } else if (typeof obj === "bigint") {
+    return obj;
+  } else if (typeof obj === "object" && obj !== null) {
+    if (Array.isArray(obj)) {
+      return obj.map(objToMetadatum);
+    } else {
+      const result = /* @__PURE__ */ new Map();
+      Object.entries(obj).forEach(([key, value]) => {
+        let convertedKey = objToMetadatum(key);
+        result.set(convertedKey, objToMetadatum(value));
+      });
+      return result;
+    }
+  } else {
+    throw new Error("objToMetadatum: Unsupported object type");
+  }
+};
+
+// src/core/adaptor/fromObj/mint.ts
+var mintItemFromObj = (obj) => {
+  if ("scriptMint" in obj) {
+    return plutusMintItemFromObj(obj.scriptMint);
+  }
+  if ("simpleScriptMint" in obj) {
+    return nativeMintItemFromObj(obj.simpleScriptMint);
+  }
+  throw new Error(
+    `mintItemFromObj: Unknown mint item format: ${JSON.stringify(obj)}`
+  );
+};
+var plutusMintItemFromObj = (obj) => {
+  const mintParams = mintParametersFromObj(obj.mint);
+  return {
+    ...mintParams,
+    type: "Plutus",
+    scriptSource: scriptSourceFromObj(obj.scriptSource),
+    redeemer: obj.redeemer ? redeemerFromObj(obj.redeemer) : void 0
+  };
+};
+var nativeMintItemFromObj = (obj) => {
+  const mintParams = mintParametersFromObj(obj.mint);
+  return {
+    ...mintParams,
+    type: "Native",
+    scriptSource: simpleScriptSourceFromObj(obj.scriptSource)
+  };
+};
+var mintParametersFromObj = (obj) => {
+  return {
+    policyId: obj.policyId,
+    assetName: obj.assetName,
+    amount: obj.amount.toString()
+  };
+};
+
+// src/core/adaptor/fromObj/network.ts
+var networkFromObj = (obj) => {
+  if (typeof obj === "string") {
+    return obj;
+  } else if (obj && typeof obj === "object" && "custom" in obj) {
+    return obj.custom;
+  }
+  throw new Error(
+    `networkFromObj: Unknown network type in object: ${JSON.stringify(obj)}`
+  );
+};
+
+// src/core/adaptor/fromObj/output.ts
+var outputFromObj = (obj) => {
+  const output = {
+    address: obj.address,
+    amount: obj.amount
+  };
+  if (obj.datum) {
+    if ("inline" in obj.datum) {
+      output.datum = {
+        type: "Inline",
+        data: cborToBuilderData(obj.datum.inline)
+      };
+    } else if ("hash" in obj.datum) {
+      output.datum = {
+        type: "Hash",
+        data: cborToBuilderData(obj.datum.hash)
+      };
+    } else if ("embedded" in obj.datum) {
+      output.datum = {
+        type: "Embedded",
+        data: cborToBuilderData(obj.datum.embedded)
+      };
+    }
+  }
+  if (obj.referenceScript) {
+    const scriptSource = obj.referenceScript.providedScriptSource;
+    output.referenceScript = {
+      code: scriptSource.scriptCbor,
+      version: scriptSource.languageVersion.toUpperCase()
+    };
+  }
+  return output;
+};
+
+// src/core/adaptor/fromObj/txIn.ts
+var txInFromObj = (obj) => {
+  if ("pubKeyTxIn" in obj) {
+    return {
+      type: "PubKey",
+      txIn: txInParameterFromObj(obj.pubKeyTxIn.txIn)
+    };
+  }
+  if ("scriptTxIn" in obj) {
+    return {
+      type: "Script",
+      txIn: txInParameterFromObj(obj.scriptTxIn.txIn),
+      scriptTxIn: scriptTxInParameterFromObj(obj.scriptTxIn.scriptTxIn)
+    };
+  }
+  if ("simpleScriptTxIn" in obj) {
+    return {
+      type: "SimpleScript",
+      txIn: txInParameterFromObj(obj.simpleScriptTxIn.txIn),
+      simpleScriptTxIn: simpleScriptTxInParameterFromObj(
+        obj.simpleScriptTxIn.simpleScriptTxIn
+      )
+    };
+  }
+  throw new Error("Invalid transaction input object format");
+};
+var txInParameterFromObj = (obj) => {
+  return {
+    txHash: obj.txHash,
+    txIndex: obj.txIndex,
+    amount: obj.amount ?? void 0,
+    address: obj.address ?? void 0
+  };
+};
+var scriptTxInParameterFromObj = (obj) => {
+  const result = {};
+  if (obj.scriptSource) {
+    result.scriptSource = scriptSourceFromObj(obj.scriptSource);
+  }
+  if (obj.datumSource) {
+    if ("providedDatumSource" in obj.datumSource) {
+      result.datumSource = {
+        type: "Provided",
+        data: cborToBuilderData(obj.datumSource.providedDatumSource.data)
+      };
+    } else if ("inlineDatumSource" in obj.datumSource) {
+      result.datumSource = {
+        type: "Inline",
+        txHash: obj.datumSource.inlineDatumSource.txHash,
+        txIndex: obj.datumSource.inlineDatumSource.txIndex
+      };
+    }
+  }
+  if (obj.redeemer) {
+    result.redeemer = redeemerFromObj(obj.redeemer);
+  }
+  return result;
+};
+var simpleScriptTxInParameterFromObj = (obj) => {
+  const result = {};
+  if ("inlineSimpleScriptSource" in obj) {
+    result.scriptSource = {
+      type: "Inline",
+      txHash: obj.inlineSimpleScriptSource.refTxIn.txHash,
+      txIndex: obj.inlineSimpleScriptSource.refTxIn.txIndex,
+      simpleScriptHash: obj.inlineSimpleScriptSource.simpleScriptHash,
+      scriptSize: obj.inlineSimpleScriptSource.scriptSize.toString()
+    };
+  } else if ("providedSimpleScriptSource" in obj) {
+    result.scriptSource = {
+      type: "Provided",
+      scriptCode: obj.providedSimpleScriptSource.scriptCbor
+    };
+  }
+  return result;
+};
+var collateralTxInFromObj = (obj) => {
+  return {
+    type: "PubKey",
+    txIn: txInParameterFromObj(obj.txIn)
+  };
+};
+
+// src/core/adaptor/fromObj/vote.ts
+var voteFromObj = (obj) => {
+  if ("basicVote" in obj) {
+    return {
+      type: "BasicVote",
+      vote: voteTypeFromObj(obj.basicVote)
+    };
+  } else if ("scriptVote" in obj) {
+    return {
+      type: "ScriptVote",
+      vote: voteTypeFromObj(obj.scriptVote.vote),
+      redeemer: redeemerFromObj(obj.scriptVote.redeemer),
+      scriptSource: scriptSourceFromObj(obj.scriptVote.scriptSource)
+    };
+  } else if ("simpleScriptVote" in obj) {
+    return {
+      type: "SimpleScriptVote",
+      vote: voteTypeFromObj(obj.simpleScriptVote.vote),
+      simpleScriptSource: simpleScriptSourceFromObj(
+        obj.simpleScriptVote.simpleScriptSource
+      )
+    };
+  }
+  throw new Error("Invalid vote object structure");
+};
+var voteTypeFromObj = (obj) => {
+  const voter = voterFromObj(obj);
+  const votingProcedure = {
+    voteKind: voteKindFromObj(obj.votingProcedure.voteKind),
+    anchor: obj.votingProcedure.anchor === null ? void 0 : obj.votingProcedure.anchor
+  };
+  return {
+    voter,
+    votingProcedure,
+    govActionId: obj.govActionId
+  };
+};
+var voterFromObj = (obj) => {
+  if ("constitutionalCommitteeHotCred" in obj.voter) {
+    const cred = obj.voter.constitutionalCommitteeHotCred;
+    return {
+      type: "ConstitutionalCommittee",
+      hotCred: "keyHash" in cred ? { type: "KeyHash", keyHash: cred.keyHash } : { type: "ScriptHash", scriptHash: cred.scriptHash }
+    };
+  } else if ("dRepId" in obj.voter) {
+    return {
+      type: "DRep",
+      drepId: obj.voter.dRepId
+    };
+  } else if ("stakingPoolKeyHash" in obj.voter) {
+    return {
+      type: "StakingPool",
+      keyHash: obj.voter.stakingPoolKeyHash
+    };
+  }
+  throw new Error("Invalid voter object structure");
+};
+var voteKindFromObj = (voteKind) => {
+  switch (voteKind.toLowerCase()) {
+    case "yes":
+      return "Yes";
+    case "no":
+      return "No";
+    case "abstain":
+      return "Abstain";
+    default:
+      throw new Error("Invalid vote kind");
+  }
+};
+
+// src/core/adaptor/fromObj/withdrawal.ts
+var withdrawalFromObj = (obj) => {
+  if ("pubKeyWithdrawal" in obj) {
+    return {
+      type: "PubKeyWithdrawal",
+      address: obj.pubKeyWithdrawal.address,
+      coin: obj.pubKeyWithdrawal.coin.toString()
+    };
+  } else if ("plutusScriptWithdrawal" in obj) {
+    return {
+      type: "ScriptWithdrawal",
+      address: obj.plutusScriptWithdrawal.address,
+      coin: obj.plutusScriptWithdrawal.coin.toString(),
+      scriptSource: obj.plutusScriptWithdrawal.scriptSource ? scriptSourceFromObj(obj.plutusScriptWithdrawal.scriptSource) : void 0,
+      redeemer: obj.plutusScriptWithdrawal.redeemer ? redeemerFromObj(obj.plutusScriptWithdrawal.redeemer) : void 0
+    };
+  } else if ("simpleScriptWithdrawal" in obj) {
+    return {
+      type: "SimpleScriptWithdrawal",
+      address: obj.simpleScriptWithdrawal.address,
+      coin: obj.simpleScriptWithdrawal.coin.toString(),
+      scriptSource: obj.simpleScriptWithdrawal.scriptSource ? simpleScriptSourceFromObj(obj.simpleScriptWithdrawal.scriptSource) : void 0
+    };
+  }
+  throw new Error("withdrawalFromObj: Invalid withdrawal object format");
+};
+
+// src/core/adaptor/fromObj/utxo.ts
+var utxoFromObj = (obj) => {
+  return {
+    input: {
+      outputIndex: obj.input.outputIndex,
+      txHash: obj.input.txHash
+    },
+    output: {
+      address: obj.output.address,
+      amount: obj.output.amount,
+      dataHash: obj.output.dataHash ?? void 0,
+      plutusData: obj.output.plutusData ?? void 0,
+      scriptRef: obj.output.scriptRef ?? void 0,
+      scriptHash: obj.output.scriptHash ?? void 0
+    }
+  };
+};
+
+// src/core/adaptor/fromObj/index.ts
+var txBuilderBodyFromObj = (objJson) => {
+  const txBuilderBody = (0, import_common5.emptyTxBuilderBody)();
+  const obj = JSON.parse(objJson);
+  if (obj.inputs && Array.isArray(obj.inputs)) {
+    txBuilderBody.inputs = obj.inputs.map(txInFromObj);
+  }
+  if (obj.outputs && Array.isArray(obj.outputs)) {
+    txBuilderBody.outputs = obj.outputs.map(outputFromObj);
+  }
+  if (obj.fee) {
+    txBuilderBody.fee = obj.fee.toString();
+  }
+  if (obj.mints && Array.isArray(obj.mints)) {
+    const mintItems = obj.mints.map(mintItemFromObj);
+    const visitedPolicyId = /* @__PURE__ */ new Set();
+    const mintParams = {};
+    mintItems.forEach((mintItem) => {
+      const mintValueItem = {
+        assetName: mintItem.assetName,
+        amount: mintItem.amount
+      };
+      if (!visitedPolicyId.has(mintItem.policyId)) {
+        const mintParam2 = {
+          type: mintItem.type,
+          policyId: mintItem.policyId,
+          mintValue: [],
+          redeemer: mintItem.redeemer,
+          scriptSource: mintItem.scriptSource
+        };
+        mintParams[mintItem.policyId] = mintParam2;
+      }
+      const mintParam = mintParams[mintItem.policyId];
+      mintParam.mintValue.push(mintValueItem);
+      visitedPolicyId.add(mintItem.policyId);
+    });
+    txBuilderBody.mints = Object.values(mintParams);
+  }
+  if (obj.withdrawals && Array.isArray(obj.withdrawals)) {
+    txBuilderBody.withdrawals = obj.withdrawals.map(withdrawalFromObj);
+  }
+  if (obj.certificates && Array.isArray(obj.certificates)) {
+    txBuilderBody.certificates = obj.certificates.map(certificateFromObj);
+  }
+  if (obj.votes && Array.isArray(obj.votes)) {
+    txBuilderBody.votes = obj.votes.map(voteFromObj);
+  }
+  if (obj.validityRange) {
+    txBuilderBody.validityRange = (0, import_common5.validityRangeFromObj)(obj.validityRange);
+  }
+  if (obj.metadata) {
+    txBuilderBody.metadata = metadataFromObj(obj.metadata);
+  }
+  if (obj.requiredSignatures && Array.isArray(obj.requiredSignatures)) {
+    txBuilderBody.requiredSignatures = [...obj.requiredSignatures];
+  }
+  if (obj.referenceInputs && Array.isArray(obj.referenceInputs)) {
+    txBuilderBody.referenceInputs = [...obj.referenceInputs];
+  }
+  if (obj.collaterals && Array.isArray(obj.collaterals)) {
+    txBuilderBody.collaterals = obj.collaterals.map(collateralTxInFromObj);
+  }
+  if (obj.changeAddress) {
+    txBuilderBody.changeAddress = obj.changeAddress;
+  }
+  if (obj.signingKey && Array.isArray(obj.signingKey)) {
+    txBuilderBody.signingKey = [...obj.signingKey];
+  }
+  if (obj.network) {
+    txBuilderBody.network = networkFromObj(obj.network);
+  }
+  return txBuilderBody;
+};
+
 // src/core/serializer.ts
+var VKEY_PUBKEY_SIZE_BYTES = 32;
+var VKEY_SIGNATURE_SIZE_BYTES = 64;
+var CHAIN_CODE_SIZE_BYTES = 32;
 var CSLSerializer = class {
   /**
    * Set to true to enable verbose logging for the txBodyJson prior going into build
    */
-  verbose;
   protocolParams;
-  meshTxBuilderBody = (0, import_common4.emptyTxBuilderBody)();
-  constructor(protocolParams, verbose = false) {
-    this.protocolParams = protocolParams || import_common4.DEFAULT_PROTOCOL_PARAMETERS;
-    this.verbose = verbose;
+  meshTxBuilderBody = (0, import_common6.emptyTxBuilderBody)();
+  parserTxBody = (0, import_common6.emptyTxBuilderBody)();
+  constructor(protocolParams) {
+    this.protocolParams = protocolParams || import_common6.DEFAULT_PROTOCOL_PARAMETERS;
   }
-  serializeTxBody(txBody, protocolParams, balanced = true) {
-    if (!balanced) {
-      throw new Error(
-        "Unbalanced transactions are not supported with CSL serializer"
-      );
-    }
-    const txBodyJson = import_json_bigint3.default.stringify(meshTxBuilderBodyToObj(txBody));
-    const params = import_json_bigint3.default.stringify(protocolParams || this.protocolParams);
-    if (this.verbose) {
-      console.log("txBodyJson", txBodyJson);
-    }
+  serializeTxBody(txBody, protocolParams) {
+    const txBodyJson = import_json_bigint4.default.stringify(meshTxBuilderBodyToObj(txBody));
+    const params = import_json_bigint4.default.stringify(protocolParams || this.protocolParams);
     const txBuildResult = csl.js_serialize_tx_body(txBodyJson, params);
     if (txBuildResult.get_status() !== "success") {
       throw new Error(`txBuildResult error: ${txBuildResult.get_error()}`);
@@ -1457,8 +2248,8 @@ var CSLSerializer = class {
       }
     },
     data: {
-      resolveDataHash: function(data) {
-        return resolveDataHash(data);
+      resolveDataHash: function(rawData, type = "Mesh") {
+        return resolveDataHash(rawData, type);
       }
     },
     script: {
@@ -1467,10 +2258,149 @@ var CSLSerializer = class {
       }
     }
   };
+  serializeOutput(output) {
+    let cslOutputBuilder = csl.TransactionOutputBuilder.new().with_address(
+      csl.Address.from_bech32(output.address)
+    );
+    if (output.datum?.type === "Hash") {
+      cslOutputBuilder.with_data_hash(
+        csl.hash_plutus_data(castDataToPlutusData(output.datum.data))
+      );
+    } else if (output.datum?.type === "Inline") {
+      cslOutputBuilder.with_plutus_data(
+        castDataToPlutusData(output.datum.data)
+      );
+    } else if (output.datum?.type === "Embedded") {
+      throw new Error("Embedded datum not supported");
+    }
+    if (output.referenceScript) {
+      switch (output.referenceScript.version) {
+        case "V1": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v1()
+              )
+            )
+          );
+          break;
+        }
+        case "V2": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v2()
+              )
+            )
+          );
+          break;
+        }
+        case "V3": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v3()
+              )
+            )
+          );
+          break;
+        }
+        default: {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_native_script(
+              csl.NativeScript.from_hex(output.referenceScript.code)
+            )
+          );
+          break;
+        }
+      }
+    }
+    return cslOutputBuilder.next().with_value(toCslValue(output.amount)).build().to_hex();
+  }
+  serializeTxBodyWithMockSignatures(txBuilderBody, protocolParams) {
+    const txHex = this.serializeTxBody(txBuilderBody, protocolParams);
+    const cslTx = csl.Transaction.from_hex(txHex);
+    const mockWitnessSet = cslTx.witness_set();
+    const mockVkeyWitnesses = mockWitnessSet.vkeys() ?? csl.Vkeywitnesses.new();
+    const mockBootstrapWitnesses = mockWitnessSet.bootstraps() ?? csl.BootstrapWitnesses.new();
+    for (let i = 0; i < txBuilderBody.expectedNumberKeyWitnesses; i++) {
+      const numberInHex = this.numberToIntegerHex(i);
+      const mockVkey = csl.Vkey.new(
+        csl.PublicKey.from_hex(this.mockPubkey(numberInHex))
+      );
+      const mockSignature = csl.Ed25519Signature.from_hex(
+        this.mockSignature(numberInHex)
+      );
+      mockVkeyWitnesses.add(csl.Vkeywitness.new(mockVkey, mockSignature));
+    }
+    this.meshTxBuilderBody.expectedByronAddressWitnesses.forEach(
+      (bootstrapWitness, i) => {
+        const address = csl.ByronAddress.from_base58(bootstrapWitness);
+        const numberInHex = this.numberToIntegerHex(i);
+        const pubKeyHex = this.mockPubkey(numberInHex);
+        const mockVkey = csl.Vkey.new(csl.PublicKey.from_hex(pubKeyHex));
+        const signature = this.mockSignature(numberInHex);
+        const chainCode = this.mockChainCode(numberInHex);
+        mockBootstrapWitnesses.add(
+          csl.BootstrapWitness.new(
+            mockVkey,
+            csl.Ed25519Signature.from_hex(signature),
+            Buffer.from(chainCode, "hex"),
+            address.attributes()
+          )
+        );
+      }
+    );
+    mockWitnessSet.set_vkeys(mockVkeyWitnesses);
+    mockWitnessSet.set_bootstraps(mockBootstrapWitnesses);
+    return csl.Transaction.new(
+      cslTx.body(),
+      mockWitnessSet,
+      cslTx.auxiliary_data()
+    ).to_hex();
+  }
+  serializeValue(value) {
+    return toCslValue(value).to_hex();
+  }
+  parser = {
+    getRequiredInputs: function(txHex) {
+      return getRequiredInputs(txHex);
+    },
+    parse: (txHex, resolvedUtxos = []) => {
+      const parser = new CSLParser(txHex, resolvedUtxos);
+      this.parserTxBody = parser.txBuilderBody;
+    },
+    toTester: () => {
+      return new import_common6.TxTester(this.parserTxBody);
+    },
+    getBuilderBody: () => {
+      return this.parserTxBody;
+    },
+    getBuilderBodyWithoutChange: () => {
+      const txBuilderBody = { ...this.parserTxBody };
+      txBuilderBody.outputs = txBuilderBody.outputs.slice(0, -1);
+      return txBuilderBody;
+    }
+  };
+  mockPubkey(numberInHex) {
+    return "0".repeat(VKEY_PUBKEY_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  }
+  mockSignature(numberInHex) {
+    return "0".repeat(VKEY_SIGNATURE_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  }
+  mockChainCode = (numberInHex) => {
+    return "0".repeat(CHAIN_CODE_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  };
+  numberToIntegerHex = (number) => {
+    return BigInt(number).toString(16);
+  };
 };
 
 // src/offline-providers/offline-evaluator.ts
-var import_common5 = require("@meshsdk/common");
+var import_common7 = require("@meshsdk/common");
 var OfflineEvaluator = class {
   fetcher;
   network;
@@ -1485,9 +2415,9 @@ var OfflineEvaluator = class {
     this.fetcher = fetcher;
     this.network = network;
     this.slotConfig = slotConfig ?? {
-      slotLength: import_common5.SLOT_CONFIG_NETWORK[network].slotLength,
-      zeroSlot: import_common5.SLOT_CONFIG_NETWORK[network].zeroSlot,
-      zeroTime: import_common5.SLOT_CONFIG_NETWORK[network].zeroTime
+      slotLength: import_common7.SLOT_CONFIG_NETWORK[network].slotLength,
+      zeroSlot: import_common7.SLOT_CONFIG_NETWORK[network].zeroSlot,
+      zeroTime: import_common7.SLOT_CONFIG_NETWORK[network].zeroTime
     };
   }
   /**
@@ -1564,14 +2494,19 @@ var OfflineEvaluator = class {
   applyCborEncoding,
   applyParamsToScript,
   baseAddressToStakeAddress,
+  baseCertFromObj,
   baseCertToObj,
   builderDataToCbor,
   calculateTxHash,
   castDataToPlutusData,
   castRawDataToJsonString,
+  cborToBuilderData,
+  certificateFromObj,
   certificateToObj,
+  collateralTxInFromObj,
   collateralTxInToObj,
   csl,
+  dataFromObj,
   deserializeAddress,
   deserializeBech32Address,
   deserializeBip32PrivateKey,
@@ -1595,23 +2530,36 @@ var OfflineEvaluator = class {
   fromLovelace,
   fromUTF8,
   getDRepIds,
+  getRequiredInputs,
   getTransactionInputs,
   getTransactionOutputs,
   getV2ScriptHash,
   keyHashToRewardAddress,
   meshTxBuilderBodyToObj,
+  metadataFromObj,
+  mintItemFromObj,
   mintItemToObj,
+  mintParametersFromObj,
   mintParametersObj,
+  nativeMintItemFromObj,
   nativeMintItemToObj,
+  networkFromObj,
+  networkToObj,
+  outputFromObj,
   outputToObj,
   parseDatumCbor,
   parseInlineDatum,
+  plutusMintItemFromObj,
   plutusMintItemToObj,
   poolIdBech32ToHex,
   poolIdHexToBech32,
+  poolMetadataFromObj,
   poolMetadataToObj,
+  poolParamsFromObj,
   poolParamsToObj,
+  redeemerFromObj,
   redeemerToObj,
+  relayFromObj,
   relayToObj,
   resolveDataHash,
   resolveEd25519KeyHash,
@@ -1627,19 +2575,24 @@ var OfflineEvaluator = class {
   rewardAddressToKeyHash,
   scriptHashToBech32,
   scriptHashToRewardAddress,
+  scriptSourceFromObj,
   scriptSourceToObj,
+  scriptTxInParameterFromObj,
   scriptTxInParameterToObj,
   serializeAddressObj,
   serializePlutusAddressToBech32,
   serializePoolId,
   serialzeAddress,
   signTransaction,
+  simpleScriptSourceFromObj,
   simpleScriptSourceToObj,
+  simpleScriptTxInParameterFromObj,
   simpleScriptTxInParameterToObj,
   skeyToPubKeyHash,
   toAddress,
   toBaseAddress,
   toBytes,
+  toCslValue,
   toEnterpriseAddress,
   toLovelace,
   toNativeScript,
@@ -1647,9 +2600,17 @@ var OfflineEvaluator = class {
   toRewardAddress,
   toScriptRef,
   toUTF8,
+  txBuilderBodyFromObj,
+  txInFromObj,
+  txInParameterFromObj,
   txInParameterToObj,
   txInToObj,
+  txMetadataToObj,
+  utxoFromObj,
   utxoToObj,
   v2ScriptToBech32,
+  voteFromObj,
+  voteToObj,
+  withdrawalFromObj,
   withdrawalToObj
 });