@meshsdk/core-csl 1.9.0-beta.54 → 1.9.0-beta.56

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,14 +121,18 @@ __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,
@@ -124,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);
@@ -541,7 +571,7 @@ 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();
 };
@@ -717,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();
@@ -744,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 {
@@ -785,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) {
@@ -969,7 +1053,7 @@ var relayToObj = (relay) => {
   }
 };
 
-// src/core/adaptor/metadata.ts
+// src/core/adaptor/toObj/metadata.ts
 var import_json_bigint2 = __toESM(require("json-bigint"), 1);
 var txMetadataToObj = (metadata) => {
   const result = [];
@@ -1004,7 +1088,7 @@ var uint8ArrayToHex = (bytes) => {
   return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 };
 
-// src/core/adaptor/mint.ts
+// src/core/adaptor/toObj/mint.ts
 var mintItemToObj = (mintItem) => {
   switch (mintItem.type) {
     case "Plutus":
@@ -1045,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;
@@ -1056,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) {
@@ -1086,7 +1170,7 @@ var outputToObj = (output) => {
   };
 };
 
-// src/core/adaptor/txIn.ts
+// src/core/adaptor/toObj/txIn.ts
 var txInToObj = (txIn) => {
   switch (txIn.type) {
     case "PubKey":
@@ -1187,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 {
@@ -1287,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 {
@@ -1331,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 }
@@ -1352,7 +1436,7 @@ var utxoToObj = ({
   };
 };
 
-// src/core/adaptor/index.ts
+// src/core/adaptor/toObj/index.ts
 var meshTxBuilderBodyToObj = ({
   inputs,
   outputs,
@@ -1394,7 +1478,7 @@ var meshTxBuilderBodyToObj = ({
     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),
@@ -1404,6 +1488,677 @@ 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;
@@ -1413,13 +2168,14 @@ var CSLSerializer = class {
    * Set to true to enable verbose logging for the txBodyJson prior going into build
    */
   protocolParams;
-  meshTxBuilderBody = (0, import_common4.emptyTxBuilderBody)();
+  meshTxBuilderBody = (0, import_common6.emptyTxBuilderBody)();
+  parserTxBody = (0, import_common6.emptyTxBuilderBody)();
   constructor(protocolParams) {
-    this.protocolParams = protocolParams || import_common4.DEFAULT_PROTOCOL_PARAMETERS;
+    this.protocolParams = protocolParams || import_common6.DEFAULT_PROTOCOL_PARAMETERS;
   }
   serializeTxBody(txBody, protocolParams) {
-    const txBodyJson = import_json_bigint3.default.stringify(meshTxBuilderBodyToObj(txBody));
-    const params = import_json_bigint3.default.stringify(protocolParams || this.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()}`);
@@ -1609,6 +2365,26 @@ var CSLSerializer = class {
   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.inputs = txBuilderBody.inputs.slice(0, -1);
+      return txBuilderBody;
+    }
+  };
   mockPubkey(numberInHex) {
     return "0".repeat(VKEY_PUBKEY_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
   }
@@ -1624,7 +2400,7 @@ var CSLSerializer = class {
 };
 
 // src/offline-providers/offline-evaluator.ts
-var import_common5 = require("@meshsdk/common");
+var import_common7 = require("@meshsdk/common");
 var OfflineEvaluator = class {
   fetcher;
   network;
@@ -1639,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
     };
   }
   /**
@@ -1718,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,
@@ -1749,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,
@@ -1781,14 +2575,18 @@ var OfflineEvaluator = class {
   rewardAddressToKeyHash,
   scriptHashToBech32,
   scriptHashToRewardAddress,
+  scriptSourceFromObj,
   scriptSourceToObj,
+  scriptTxInParameterFromObj,
   scriptTxInParameterToObj,
   serializeAddressObj,
   serializePlutusAddressToBech32,
   serializePoolId,
   serialzeAddress,
   signTransaction,
+  simpleScriptSourceFromObj,
   simpleScriptSourceToObj,
+  simpleScriptTxInParameterFromObj,
   simpleScriptTxInParameterToObj,
   skeyToPubKeyHash,
   toAddress,
@@ -1802,9 +2600,17 @@ var OfflineEvaluator = class {
   toRewardAddress,
   toScriptRef,
   toUTF8,
+  txBuilderBodyFromObj,
+  txInFromObj,
+  txInParameterFromObj,
   txInParameterToObj,
   txInToObj,
+  txMetadataToObj,
+  utxoFromObj,
   utxoToObj,
   v2ScriptToBech32,
+  voteFromObj,
+  voteToObj,
+  withdrawalFromObj,
   withdrawalToObj
 });