@meshsdk/core-cst 1.8.13 → 1.9.0-beta.0

package/dist/index.js

@@ -545,7 +545,7 @@ var require_blake2b = __commonJS({
       }
       return out;
     }
-    function blake2b5(input, key, outlen, salt, personal) {
+    function blake2b7(input, key, outlen, salt, personal) {
       outlen = outlen || 64;
       input = util.normalizeInput(input);
       if (salt) {
@@ -559,11 +559,11 @@ var require_blake2b = __commonJS({
       return blake2bFinal(ctx);
     }
     function blake2bHex(input, key, outlen, salt, personal) {
-      const output = blake2b5(input, key, outlen, salt, personal);
+      const output = blake2b7(input, key, outlen, salt, personal);
       return util.toHex(output);
     }
     module.exports = {
-      blake2b: blake2b5,
+      blake2b: blake2b7,
       blake2bHex,
       blake2bInit,
       blake2bUpdate,
@@ -887,7 +887,7 @@ var require_blakejs = __commonJS({
 });
 
 // src/index.ts
-import { Cardano as Cardano4, Serialization as Serialization5 } from "@cardano-sdk/core";
+import { Cardano as Cardano5, Serialization as Serialization7 } from "@cardano-sdk/core";
 
 // src/types/cardano-sdk.ts
 import { Cardano, Serialization } from "@cardano-sdk/core";
@@ -899,6 +899,10 @@ var Transaction = Serialization.Transaction;
 var TransactionId = Cardano.TransactionId;
 var TransactionBody = Serialization.TransactionBody;
 var TransactionWitnessSet = Serialization.TransactionWitnessSet;
+var AuxilliaryData = Serialization.AuxiliaryData;
+var TransactionMetadatum = Serialization.TransactionMetadatum;
+var MetadatumMap = Serialization.MetadatumMap;
+var MetadatumList = Serialization.MetadatumList;
 var TransactionUnspentOutput = Serialization.TransactionUnspentOutput;
 var TransactionInput = Serialization.TransactionInput;
 var TransactionOutput = Serialization.TransactionOutput;
@@ -946,6 +950,10 @@ var NativeScript = Serialization.NativeScript;
 var PlutusV1Script = Serialization.PlutusV1Script;
 var PlutusV2Script = Serialization.PlutusV2Script;
 var PlutusV3Script = Serialization.PlutusV3Script;
+var PlutusDataKind = Serialization.PlutusDataKind;
+var PointerAddress = Cardano.PointerAddress;
+var CertIndex = Cardano.CertIndex;
+var TxIndex = Cardano.TxIndex;
 var Costmdls = Serialization.Costmdls;
 var CostModel = Serialization.CostModel;
 var CborWriter = Serialization.CborWriter;
@@ -969,6 +977,8 @@ var ScriptPubkey = Serialization.ScriptPubkey;
 var DRepID = Cardano.DRepID;
 var DRep = Serialization.DRep;
 var StakeCredentialStatus = Cardano.StakeCredentialStatus;
+var computeAuxiliaryDataHash = Cardano.computeAuxiliaryDataHash;
+var blake2b2 = Crypto.blake2b;
 
 // src/stricahq/bip32ed25519/wrapper.ts
 import * as cjsBip32ed25519 from "@stricahq/bip32ed25519";
@@ -1256,11 +1266,18 @@ var signData = (data, signer) => {
 
 // src/resolvers/index.ts
 import { Cardano as Cardano2 } from "@cardano-sdk/core";
-import { blake2b as blake2b3 } from "@cardano-sdk/crypto";
-import { HexBlob as HexBlob4 } from "@cardano-sdk/util";
+import { blake2b as blake2b5 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob6 } from "@cardano-sdk/util";
+import base323 from "base32-encoding";
+import { bech32 as bech323 } from "bech32";
+import {
+  fromUTF8,
+  mnemonicToEntropy,
+  toBytes as toBytes4
+} from "@meshsdk/common";
 
 // src/utils/builder.ts
-import { blake2b as blake2b2 } from "@cardano-sdk/crypto";
+import { blake2b as blake2b4 } from "@cardano-sdk/crypto";
 import { HexBlob } from "@cardano-sdk/util";
 import { pbkdf2Sync } from "pbkdf2";
 import { HARDENED_KEY_START } from "@meshsdk/common";
@@ -1338,7 +1355,7 @@ var buildScriptPubkey = (keyHash) => {
 };
 var buildDRepID = (dRepKey, networkId = NetworkId.Testnet, addressType = AddressType.EnterpriseKey) => {
   const dRepKeyBytes = Buffer.from(dRepKey, "hex");
-  const dRepIdHex = blake2b2(28).update(dRepKeyBytes).digest("hex");
+  const dRepIdHex = blake2b4(28).update(dRepKeyBytes).digest("hex");
   const paymentAddress = EnterpriseAddress.packParts({
     networkId,
     paymentPart: {
@@ -1354,55 +1371,265 @@ var buildDRepID = (dRepKey, networkId = NetworkId.Testnet, addressType = Address
 };
 
 // src/utils/converter.ts
-import { Serialization as Serialization2 } from "@cardano-sdk/core";
+import { Serialization as Serialization3 } from "@cardano-sdk/core";
 import { Ed25519KeyHash as Ed25519KeyHash4 } from "@cardano-sdk/crypto";
-import { HexBlob as HexBlob3 } from "@cardano-sdk/util";
+import { HexBlob as HexBlob4 } from "@cardano-sdk/util";
+import base32 from "base32-encoding";
+import { bech32 } from "bech32";
 import {
-  toBytes as toBytes2
+  toBytes as toBytes3
 } from "@meshsdk/common";
 
-// src/utils/deserializer.ts
-import { TxCBOR } from "@cardano-sdk/core";
-import { Ed25519KeyHashHex as Ed25519KeyHashHex3 } from "@cardano-sdk/crypto";
+// src/utils/data.ts
 import { HexBlob as HexBlob2 } from "@cardano-sdk/util";
 import { toBytes } from "@meshsdk/common";
-var deserializeAddress = (address) => {
-  const _address = Address.fromString(address);
-  if (_address === null) throw new Error("Invalid address");
-  return _address;
+var toPlutusData = (data) => {
+  const toPlutusList = (data2) => {
+    const plutusList = new PlutusList();
+    data2.forEach((element) => {
+      plutusList.add(toPlutusData(element));
+    });
+    return plutusList;
+  };
+  switch (typeof data) {
+    case "string":
+      return PlutusData.newBytes(toBytes(data));
+    case "number":
+      return PlutusData.newInteger(BigInt(data));
+    case "bigint":
+      return PlutusData.newInteger(BigInt(data));
+    case "object":
+      if (data instanceof Array) {
+        const plutusList = toPlutusList(data);
+        return PlutusData.newList(plutusList);
+      } else if (data instanceof Map) {
+        const plutusMap = new PlutusMap();
+        data.forEach((value, key) => {
+          plutusMap.insert(toPlutusData(key), toPlutusData(value));
+        });
+        return PlutusData.newMap(plutusMap);
+      } else {
+        return PlutusData.newConstrPlutusData(
+          new ConstrPlutusData(
+            BigInt(data.alternative),
+            toPlutusList(data.fields)
+          )
+        );
+      }
+  }
+};
+var isConstrPlutusDataJson = (data) => {
+  return typeof data === "object" && "constructor" in data && (typeof data.constructor === "number" || typeof data.constructor === "bigint" || typeof data.constructor === "string") && "fields" in data && Array.isArray(data.fields);
+};
+function isMapPlutusDataJson(data) {
+  return typeof data === "object" && Array.isArray(data);
+}
+function isKeyValuePlutusDataJson(data) {
+  return typeof data === "object" && "k" in data && typeof data.k === "object" && "v" in data && typeof data.v === "object";
+}
+var fromJsonToPlutusData = (data) => {
+  if (isConstrPlutusDataJson(data)) {
+    const plutusList = new PlutusList();
+    data.fields.map((val) => {
+      plutusList.add(fromJsonToPlutusData(val));
+    });
+    const plutusConstrData = new ConstrPlutusData(
+      BigInt(data.constructor),
+      plutusList
+    );
+    return PlutusData.newConstrPlutusData(plutusConstrData);
+  } else if ("int" in data && Object.keys(data).length === 1) {
+    if (typeof data.int === "bigint" || typeof data.int === "number" || typeof data.int === "string") {
+      return PlutusData.newInteger(BigInt(data.int));
+    } else {
+      throw new Error(
+        "Malformed int field in Plutus data, expected one of bigint, number or string"
+      );
+    }
+  } else if ("bytes" in data && Object.keys(data).length === 1) {
+    if (typeof data.bytes === "string") {
+      return PlutusData.newBytes(Buffer.from(data.bytes, "hex"));
+    } else {
+      throw new Error("Malformed bytes field in Plutus data, expected string");
+    }
+  } else if ("list" in data && Object.keys(data).length === 1) {
+    if (Array.isArray(data.list)) {
+      const plutusList = new PlutusList();
+      data.list.map((val) => {
+        plutusList.add(fromJsonToPlutusData(val));
+      });
+      return PlutusData.newList(plutusList);
+    } else {
+      throw new Error("Malformed list field in Plutus data, expected list");
+    }
+  } else if ("map" in data && Object.keys(data).length === 1) {
+    if (isMapPlutusDataJson(data.map)) {
+      const plutusMap = new PlutusMap();
+      data.map.forEach((val) => {
+        if (isKeyValuePlutusDataJson(val)) {
+          plutusMap.insert(
+            fromJsonToPlutusData(val.k),
+            fromJsonToPlutusData(val.v)
+          );
+        } else {
+          throw new Error("Malformed key value pair in Plutus data map");
+        }
+      });
+      return PlutusData.newMap(plutusMap);
+    } else {
+      console.log(data);
+      throw new Error("Malformed map field in Plutus data");
+    }
+  } else {
+    throw new Error("Malformed Plutus data json");
+  }
+};
+var fromBuilderToPlutusData = (data) => {
+  if (data.type === "Mesh") {
+    return toPlutusData(data.content);
+  } else if (data.type === "CBOR") {
+    return PlutusData.fromCbor(HexBlob2(data.content));
+  } else if (data.type === "JSON") {
+    let content;
+    if (typeof data.content === "string") {
+      content = JSON.parse(data.content);
+    } else {
+      content = data.content;
+    }
+    return fromJsonToPlutusData(content);
+  } else {
+    throw new Error(
+      "Malformed builder data, expected types of, Mesh, CBOR or JSON"
+    );
+  }
+};
+var fromPlutusDataToJson = (data) => {
+  if (data.getKind() === PlutusDataKind.ConstrPlutusData) {
+    const plutusData = data.asConstrPlutusData();
+    if (plutusData) {
+      const fields = plutusData.getData();
+      return {
+        constructor: plutusData.getAlternative(),
+        fields: fromPlutusDataToJson(PlutusData.newList(fields))
+      };
+    } else {
+      throw new Error("Invalid constructor data found");
+    }
+  } else if (data.getKind() === PlutusDataKind.Map) {
+    const plutusMap = data.asMap();
+    const mapList = [];
+    if (plutusMap) {
+      const keys = plutusMap.getKeys();
+      for (let i = 0; i < keys.getLength(); i++) {
+        const key = keys.get(i);
+        const value = plutusMap.get(key);
+        if (value) {
+          mapList.push({
+            k: fromPlutusDataToJson(key),
+            v: fromPlutusDataToJson(value)
+          });
+        }
+      }
+      return {
+        map: mapList
+      };
+    } else {
+      throw new Error("Invalid map data found");
+    }
+  } else if (data.getKind() === PlutusDataKind.List) {
+    const plutusList = data.asList();
+    if (plutusList) {
+      const list = [];
+      for (let i = 0; i < plutusList.getLength(); i++) {
+        const element = plutusList.get(i);
+        list.push(fromPlutusDataToJson(element));
+      }
+      return list;
+    } else {
+      throw new Error("Invalid list data found");
+    }
+  } else if (data.getKind() === PlutusDataKind.Integer) {
+    const plutusInt = data.asInteger();
+    if (plutusInt) {
+      return {
+        int: BigInt(plutusInt.toString())
+      };
+    } else {
+      throw new Error("Invalid integer data found");
+    }
+  } else if (data.getKind() === PlutusDataKind.Bytes) {
+    const plutusBytes = data.asBoundedBytes();
+    if (plutusBytes) {
+      return {
+        bytes: Buffer.from(plutusBytes).toString("hex")
+      };
+    } else {
+      throw new Error("Invalid bytes data found");
+    }
+  } else {
+    throw new Error("Invalid Plutus data found");
+  }
+};
+var datumCborToJson = (datumCbor) => {
+  const parsedDatum = PlutusData.fromCbor(HexBlob2(datumCbor));
+  return fromPlutusDataToJson(parsedDatum);
+};
+var parseDatumCbor = (datumCbor) => {
+  return datumCborToJson(datumCbor);
+};
+var parseInlineDatum = (utxo) => {
+  const datumCbor = utxo.inline_datum || "";
+  return datumCborToJson(datumCbor);
 };
-var deserializeEd25519KeyHash = (ed25519KeyHash) => Ed25519KeyHash2.fromBytes(toBytes(ed25519KeyHash));
 var deserializeDataHash = (dataHash) => DatumHash.fromHexBlob(HexBlob2(dataHash));
 var deserializePlutusData = (plutusData) => PlutusData.fromCbor(HexBlob2(plutusData));
+
+// src/utils/deserializer.ts
+import { Serialization as Serialization2 } from "@cardano-sdk/core";
+import { Ed25519KeyHashHex as Ed25519KeyHashHex3 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob3 } from "@cardano-sdk/util";
+import { toBytes as toBytes2 } from "@meshsdk/common";
+var deserializeEd25519KeyHash = (ed25519KeyHash) => Ed25519KeyHash2.fromBytes(toBytes2(ed25519KeyHash));
 var deserializePlutusScript = (plutusScript, version) => {
   switch (version) {
     case "V1":
-      return PlutusV1Script.fromCbor(HexBlob2(plutusScript));
+      return PlutusV1Script.fromCbor(HexBlob3(plutusScript));
     case "V2":
-      return PlutusV2Script.fromCbor(HexBlob2(plutusScript));
+      return PlutusV2Script.fromCbor(HexBlob3(plutusScript));
     case "V3":
-      return PlutusV3Script.fromCbor(HexBlob2(plutusScript));
+      return PlutusV3Script.fromCbor(HexBlob3(plutusScript));
     default:
       throw new Error("Invalid Plutus script version");
   }
 };
-var deserializeNativeScript = (nativeScript) => NativeScript.fromCbor(HexBlob2(nativeScript));
+var deserializeNativeScript = (nativeScript) => NativeScript.fromCbor(HexBlob3(nativeScript));
 var deserializeScriptHash = (scriptHash) => ScriptHash.fromEd25519KeyHashHex(Ed25519KeyHashHex3(scriptHash));
-var deserializeScriptRef = (scriptRef) => Script.fromCbor(HexBlob2(scriptRef));
-var deserializeTxUnspentOutput = (txUnspentOutput) => TransactionUnspentOutput.fromCbor(HexBlob2(txUnspentOutput));
-var deserializeValue = (value) => Value.fromCbor(HexBlob2(value));
-var deserializeTx = (tx) => Transaction.fromCbor(TxCBOR(tx));
-var deserializeTxHash = (txHash) => TransactionId.fromHexBlob(HexBlob2(txHash));
+var deserializeScriptRef = (scriptRef) => Script.fromCbor(HexBlob3(scriptRef));
+var deserializeTxUnspentOutput = (txUnspentOutput) => TransactionUnspentOutput.fromCbor(HexBlob3(txUnspentOutput));
+var deserializeValue = (value) => Value.fromCbor(HexBlob3(value));
+var deserializeTx = (tx) => Transaction.fromCbor(Serialization2.TxCBOR(tx));
+var deserializeTxHash = (txHash) => TransactionId.fromHexBlob(HexBlob3(txHash));
 
 // src/utils/converter.ts
-var toAddress = (bech32) => Address.fromBech32(bech32);
-var toBaseAddress = (bech32) => {
-  return BaseAddress.fromAddress(toAddress(bech32));
+var toAddress = (bech325) => Address.fromBech32(bech325);
+var toCardanoAddress = (address) => {
+  try {
+    return Address.fromBech32(address);
+  } catch {
+    try {
+      return Address.fromBase58(address);
+    } catch {
+      throw new Error("Invalid address format");
+    }
+  }
 };
-var toEnterpriseAddress = (bech32) => {
-  return EnterpriseAddress.fromAddress(toAddress(bech32));
+var toBaseAddress = (bech325) => {
+  return BaseAddress.fromAddress(toAddress(bech325));
 };
-var toRewardAddress = (bech32) => RewardAddress.fromAddress(toAddress(bech32));
+var toEnterpriseAddress = (bech325) => {
+  return EnterpriseAddress.fromAddress(toAddress(bech325));
+};
+var toRewardAddress = (bech325) => RewardAddress.fromAddress(toAddress(bech325));
 var fromTxUnspentOutput = (txUnspentOutput) => {
   const dataHash = txUnspentOutput.output().datum() ? txUnspentOutput.output().datum()?.toCbor().toString() : void 0;
   const scriptRef = txUnspentOutput.output().scriptRef() ? txUnspentOutput.output().scriptRef()?.toCbor().toString() : void 0;
@@ -1440,7 +1667,7 @@ var toTxUnspentOutput = (utxo) => {
   }
   if (utxo.output.plutusData !== void 0) {
     const plutusData = deserializePlutusData(utxo.output.plutusData);
-    const datum = new Serialization2.Datum(void 0, plutusData);
+    const datum = new Serialization3.Datum(void 0, plutusData);
     txOutput.setDatum(datum);
   }
   if (utxo.output.scriptRef !== void 0) {
@@ -1486,7 +1713,7 @@ var toScriptRef = (script) => {
   return Script.newNativeScript(toNativeScript(script));
 };
 var fromScriptRef = (scriptRef) => {
-  const script = Script.fromCbor(HexBlob3(scriptRef));
+  const script = Script.fromCbor(HexBlob4(scriptRef));
   const plutusScriptCodeV3 = script.asPlutusV3()?.toCbor().toString();
   if (plutusScriptCodeV3) {
     return {
@@ -1584,70 +1811,35 @@ var toNativeScript = (script) => {
   switch (script.type) {
     case "all":
       return NativeScript.newScriptAll(
-        new Serialization2.ScriptAll(toNativeScripts(script.scripts))
+        new Serialization3.ScriptAll(toNativeScripts(script.scripts))
       );
     case "any":
       return NativeScript.newScriptAny(
-        new Serialization2.ScriptAny(toNativeScripts(script.scripts))
+        new Serialization3.ScriptAny(toNativeScripts(script.scripts))
       );
     case "atLeast":
       return NativeScript.newScriptNOfK(
-        new Serialization2.ScriptNOfK(
+        new Serialization3.ScriptNOfK(
           toNativeScripts(script.scripts),
           script.required
         )
       );
     case "after":
       return NativeScript.newTimelockStart(
-        new Serialization2.TimelockStart(Slot(parseInt(script.slot)))
+        new Serialization3.TimelockStart(Slot(parseInt(script.slot)))
       );
     case "before":
       return NativeScript.newTimelockExpiry(
-        new Serialization2.TimelockExpiry(Slot(parseInt(script.slot)))
+        new Serialization3.TimelockExpiry(Slot(parseInt(script.slot)))
       );
     case "sig":
       return NativeScript.newScriptPubkey(
-        new Serialization2.ScriptPubkey(
-          Ed25519KeyHash4.fromBytes(toBytes2(script.keyHash)).hex()
+        new Serialization3.ScriptPubkey(
+          Ed25519KeyHash4.fromBytes(toBytes3(script.keyHash)).hex()
         )
       );
   }
 };
-var toPlutusData = (data) => {
-  const toPlutusList = (data2) => {
-    const plutusList = new PlutusList();
-    data2.forEach((element) => {
-      plutusList.add(toPlutusData(element));
-    });
-    return plutusList;
-  };
-  switch (typeof data) {
-    case "string":
-      return PlutusData.newBytes(toBytes2(data));
-    case "number":
-      return PlutusData.newInteger(BigInt(data));
-    case "bigint":
-      return PlutusData.newInteger(BigInt(data));
-    case "object":
-      if (data instanceof Array) {
-        const plutusList = toPlutusList(data);
-        return PlutusData.newList(plutusList);
-      } else if (data instanceof Map) {
-        const plutusMap = new PlutusMap();
-        data.forEach((value, key) => {
-          plutusMap.insert(toPlutusData(key), toPlutusData(value));
-        });
-        return PlutusData.newMap(plutusMap);
-      } else {
-        return PlutusData.newConstrPlutusData(
-          new ConstrPlutusData(
-            BigInt(data.alternative),
-            toPlutusList(data.fields)
-          )
-        );
-      }
-  }
-};
 var toValue = (assets) => {
   const multiAsset = /* @__PURE__ */ new Map();
   assets.filter((asset) => asset.unit !== "lovelace").forEach((asset) => {
@@ -1660,6 +1852,102 @@ var toValue = (assets) => {
   }
   return value;
 };
+var toDRep = (dRepId) => {
+  if (dRepId.length === 58) {
+    const { prefix, words } = bech32.decode(dRepId);
+    if (prefix !== "drep") {
+      throw new Error("Invalid DRepId prefix");
+    }
+    const bytes = base32.decode(new Uint8Array(words));
+    if (bytes[0] === 34) {
+      return Serialization3.DRep.newKeyHash(
+        Ed25519KeyHashHex2(bytes.subarray(1).toString("hex"))
+      );
+    } else if (bytes[0] === 35) {
+      return Serialization3.DRep.newScriptHash(
+        Hash28ByteBase162(bytes.subarray(1).toString("hex"))
+      );
+    } else {
+      throw new Error("Malformed CIP129 DRepId");
+    }
+  } else {
+    const { prefix, words } = bech32.decode(dRepId);
+    switch (prefix) {
+      case "drep": {
+        return Serialization3.DRep.newKeyHash(
+          Ed25519KeyHashHex2(
+            base32.decode(new Uint8Array(words)).toString("hex")
+          )
+        );
+      }
+      case "drep_script": {
+        return Serialization3.DRep.newScriptHash(
+          Hash28ByteBase162(
+            base32.decode(new Uint8Array(words)).toString("hex")
+          )
+        );
+      }
+      default: {
+        throw new Error("Malformed DRepId prefix");
+      }
+    }
+  }
+};
+var getDRepIds = (dRepId) => {
+  let result = {
+    cip105: "",
+    cip129: ""
+  };
+  if (dRepId.length === 58) {
+    result.cip129 = dRepId;
+    const { prefix, words } = bech32.decode(dRepId);
+    if (prefix !== "drep") {
+      throw new Error("Malformed CIP129 DRepId");
+    }
+    const bytes = base32.decode(new Uint8Array(words));
+    if (bytes[0] === 34) {
+      result.cip105 = bech32.encode("drep", base32.encode(bytes.subarray(1)));
+    } else if (bytes[0] === 35) {
+      result.cip105 = bech32.encode(
+        "drep_script",
+        base32.encode(bytes.subarray(1))
+      );
+    } else {
+      throw new Error("Malformed CIP129 DRepId");
+    }
+  } else {
+    result.cip105 = dRepId;
+    try {
+      const { prefix, words } = bech32.decode(dRepId);
+      let rawBytes = base32.decode(new Uint8Array(words));
+      if (prefix === "drep") {
+        if (!rawBytes) {
+          throw new Error("Malformed key hash in DRepId");
+        }
+        let rawBytesWithPrefix = new Uint8Array(rawBytes.length + 1);
+        rawBytesWithPrefix.set([34]);
+        rawBytesWithPrefix.set(rawBytes, 1);
+        let base32RawBytes = base32.encode(rawBytesWithPrefix);
+        result.cip129 = bech32.encode("drep", base32RawBytes);
+      } else if (prefix === "drep_script") {
+        if (!rawBytes) {
+          throw new Error("Malformed script hash in DRepId");
+        }
+        let rawBytesWithPrefix = new Uint8Array(rawBytes.length + 1);
+        rawBytesWithPrefix.set([35]);
+        rawBytesWithPrefix.set(rawBytes, 1);
+        let base32RawBytes = base32.encode(rawBytesWithPrefix);
+        result.cip129 = bech32.encode("drep", base32RawBytes);
+      } else {
+        throw new Error("Can only calculate DRepIds for script/key DReps");
+      }
+    } catch (e) {
+      console.error(e);
+      throw new Error("Malformed DRepId");
+    }
+  }
+  return result;
+};
 
 // src/utils/value.ts
 function mergeValue(a, b) {
@@ -1717,115 +2005,907 @@ function empty(v) {
   return assetTypes(v) == 0;
 }
 
-// src/utils/encoding.ts
-var hexToBytes = (hex) => Buffer.from(hex, "hex");
-
-// src/resolvers/index.ts
-var resolveDataHash = (data) => {
-  const plutusData = toPlutusData(data);
-  return plutusData.hash().toString();
-};
-var resolveNativeScriptAddress = (script, networkId = 0) => {
-  const nativeScript = toNativeScript(script);
-  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
-    hash: nativeScript.hash(),
-    type: Cardano2.CredentialType.ScriptHash
-  });
-  return enterpriseAddress.toAddress().toBech32();
-};
-var resolveNativeScriptHash = (script) => {
-  return toNativeScript(script).hash().toString();
-};
-var resolvePaymentKeyHash = (bech32) => {
-  try {
-    const paymentKeyHash = [
-      toBaseAddress(bech32)?.getPaymentCredential().hash,
-      toEnterpriseAddress(bech32)?.getPaymentCredential().hash
-    ].find((kh) => kh !== void 0);
-    if (paymentKeyHash !== void 0) return paymentKeyHash.toString();
+// src/utils/address.ts
+import { HexBlob as HexBlob5 } from "@cardano-sdk/util";
+import {
+  pubKeyAddress,
+  scriptAddress
+} from "@meshsdk/common";
+var serialzeAddress = (deserializedAddress, networkId = 0) => {
+  const {
+    pubKeyHash,
+    scriptHash,
+    stakeCredentialHash,
+    stakeScriptCredentialHash
+  } = deserializedAddress;
+  const isPaymentScript = !pubKeyHash;
+  const isStakeScript = !stakeCredentialHash;
+  const paymentHash = isPaymentScript ? scriptHash : pubKeyHash;
+  const stakeHash = isStakeScript ? stakeScriptCredentialHash : stakeCredentialHash;
+  if (!paymentHash)
     throw new Error(
-      `Couldn't resolve payment key hash from address: ${bech32}`
+      "Error: serializeAddress: Address must contain a payment part"
     );
-  } catch (error) {
+  const addressObj = isPaymentScript ? scriptAddress(paymentHash, stakeHash, isStakeScript) : pubKeyAddress(paymentHash, stakeHash, isStakeScript);
+  return serializeAddressObj(addressObj, networkId);
+};
+var addrBech32ToPlutusData = (bech325) => {
+  const cardanoAddress = Address.fromBech32(bech325);
+  const cardanoAddressProps = cardanoAddress.getProps();
+  const paymentPartList = new PlutusList();
+  if (!cardanoAddressProps.paymentPart) {
     throw new Error(
-      `An error occurred during resolvePaymentKeyHash: ${error}.`
+      "Error: addrBech32ToPlutusDataHex: Address must contain a payment part"
     );
   }
-};
-var resolvePlutusScriptAddress = (script, networkId = 0) => {
-  const plutusScript = deserializePlutusScript(script.code, script.version);
-  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
-    hash: plutusScript.hash(),
-    type: Cardano2.CredentialType.ScriptHash
-  });
-  return enterpriseAddress.toAddress().toBech32();
-};
-var resolvePlutusScriptHash = (bech32) => {
-  try {
-    const enterpriseAddress = toEnterpriseAddress(bech32);
-    const scriptHash = enterpriseAddress?.getPaymentCredential().hash;
-    if (scriptHash !== void 0) return scriptHash.toString();
-    throw new Error(`Couldn't resolve script hash from address: ${bech32}`);
-  } catch (error) {
-    throw new Error(`An error occurred during resolveScriptHash: ${error}.`);
+  paymentPartList.add(
+    PlutusData.newBytes(
+      Buffer.from(cardanoAddressProps.paymentPart.hash, "hex")
+    )
+  );
+  const paymentPart = PlutusData.newConstrPlutusData(
+    new ConstrPlutusData(
+      BigInt(cardanoAddressProps.paymentPart.type),
+      paymentPartList
+    )
+  );
+  const delegationPartList = new PlutusList();
+  let delegationPart;
+  if (cardanoAddressProps.delegationPart) {
+    delegationPartList.add(
+      PlutusData.newBytes(
+        Buffer.from(cardanoAddressProps.delegationPart.hash, "hex")
+      )
+    );
+    const inlineDelegationPart = PlutusData.newConstrPlutusData(
+      new ConstrPlutusData(BigInt(0), delegationPartList)
+    );
+    const someList = new PlutusList();
+    someList.add(inlineDelegationPart);
+    delegationPart = PlutusData.newConstrPlutusData(
+      new ConstrPlutusData(BigInt(0), someList)
+    );
+  } else if (cardanoAddressProps.pointer) {
+    const pointerList = new PlutusList();
+    pointerList.add(
+      PlutusData.newInteger(BigInt(cardanoAddressProps.pointer.slot))
+    );
+    pointerList.add(
+      PlutusData.newInteger(BigInt(cardanoAddressProps.pointer.txIndex))
+    );
+    pointerList.add(
+      PlutusData.newInteger(BigInt(cardanoAddressProps.pointer.certIndex))
+    );
+    const pointer = PlutusData.newConstrPlutusData(
+      new ConstrPlutusData(BigInt(1), pointerList)
+    );
+    const someList = new PlutusList();
+    someList.add(pointer);
+    delegationPart = PlutusData.newConstrPlutusData(
+      new ConstrPlutusData(BigInt(0), someList)
+    );
+  } else {
+    delegationPart = PlutusData.newConstrPlutusData(
+      new ConstrPlutusData(BigInt(1), new PlutusList())
+    );
   }
+  const addressList = new PlutusList();
+  addressList.add(paymentPart);
+  addressList.add(delegationPart);
+  return PlutusData.newConstrPlutusData(
+    new ConstrPlutusData(BigInt(0), addressList)
+  );
 };
-var resolvePoolId = (hash) => {
-  return Ed25519KeyHashHex2(hash).toString();
-};
-var resolvePrivateKey = (words) => {
-  return "not implemented";
+var addrBech32ToPlutusDataHex = (bech325) => {
+  return addrBech32ToPlutusData(bech325).toCbor();
 };
-var resolveScriptRef = (script) => {
-  return toScriptRef(script).toCbor().toString();
+var addrBech32ToPlutusDataObj = (bech325) => {
+  return fromPlutusDataToJson(addrBech32ToPlutusData(bech325));
 };
-var resolveRewardAddress = (bech32) => {
-  try {
-    const address = toAddress(bech32);
-    const baseAddress = toBaseAddress(bech32);
-    const stakeKeyHash = baseAddress?.getStakeCredential().hash;
-    if (stakeKeyHash !== void 0)
-      return buildRewardAddress(address.getNetworkId(), stakeKeyHash).toAddress().toBech32();
-    throw new Error(`Couldn't resolve reward address from address: ${bech32}`);
-  } catch (error) {
-    throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
+var plutusDataToAddrBech32 = (plutusData, networkId = 0) => {
+  const constrPlutusData = plutusData.asConstrPlutusData();
+  if (!constrPlutusData || constrPlutusData.getAlternative() !== BigInt(0)) {
+    throw new Error(
+      "Error: serializeAddressObj: Address must contain a constructor 0"
+    );
   }
-};
-var resolveStakeKeyHash = (bech32) => {
-  try {
-    const stakeKeyHash = [
-      toBaseAddress(bech32)?.getStakeCredential().hash,
-      toRewardAddress(bech32)?.getPaymentCredential().hash
-    ].find((kh) => kh !== void 0);
-    if (stakeKeyHash !== void 0) return stakeKeyHash.toString();
-    throw new Error(`Couldn't resolve stake key hash from address: ${bech32}`);
-  } catch (error) {
-    throw new Error(`An error occurred during resolveStakeKeyHash: ${error}.`);
+  const plutusDataList = constrPlutusData.getData();
+  if (plutusDataList.getLength() !== 2) {
+    throw new Error("Error: serializeAddressObj: Address must contain 2 parts");
   }
-};
+  const paymentData = plutusDataList.get(0);
+  const paymentConstrData = paymentData.asConstrPlutusData();
+  if (!paymentConstrData) {
+    throw new Error(
+      "Error: serializeAddressObj: Payment part must be a constructor"
+    );
+  }
+  const paymentConstrDataList = paymentConstrData.getData();
+  if (paymentConstrDataList.getLength() !== 1) {
+    throw new Error(
+      "Error: serializeAddressObj: Payment part must contain 1 element"
+    );
+  }
+  const paymentBytes = paymentConstrDataList.get(0).asBoundedBytes();
+  if (!paymentBytes) {
+    throw new Error(
+      "Error: serializeAddressObj: Payment inner part must be bytes"
+    );
+  }
+  if (paymentConstrData.getAlternative() !== BigInt(0) && paymentConstrData.getAlternative() !== BigInt(1)) {
+    throw new Error(
+      "Error: serializeAddressObj: Payment part must be alternative 0 or 1"
+    );
+  }
+  const cardanoPaymentCredential = {
+    hash: Hash28ByteBase162(Buffer.from(paymentBytes).toString("hex")),
+    type: paymentConstrData.getAlternative() === BigInt(0) ? 0 : 1
+  };
+  const delegationData = plutusDataList.get(1);
+  const delegationConstrData = delegationData.asConstrPlutusData();
+  if (!delegationConstrData) {
+    throw new Error(
+      "Error: serializeAddressObj: Delegation part must be a constructor"
+    );
+  }
+  if (delegationConstrData.getAlternative() === BigInt(1)) {
+    return EnterpriseAddress.fromCredentials(
+      networkId,
+      cardanoPaymentCredential
+    ).toAddress().toBech32();
+  } else if (delegationConstrData.getAlternative() === BigInt(0)) {
+    const delegationDataList = delegationConstrData.getData();
+    if (delegationDataList.getLength() !== 1) {
+      throw new Error(
+        "Error: serializeAddressObj: Delegation part must contain 1 element"
+      );
+    }
+    const delegationDataInner = delegationDataList.get(0);
+    const delegationDataInnerConstrData = delegationDataInner.asConstrPlutusData();
+    if (!delegationDataInnerConstrData) {
+      throw new Error(
+        "Error: serializeAddressObj: Delegation inner part must be a constructor"
+      );
+    }
+    if (delegationDataInnerConstrData.getAlternative() === BigInt(0)) {
+      const delegationDataInnerList = delegationDataInnerConstrData.getData();
+      if (delegationDataInnerList.getLength() !== 1) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part must contain 1 element"
+        );
+      }
+      const delegationBytes = delegationDataInnerList.get(0).asBoundedBytes();
+      if (!delegationBytes) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part must be bytes"
+        );
+      }
+      const cardanoStakeCredential = {
+        hash: Hash28ByteBase162(Buffer.from(delegationBytes).toString("hex")),
+        type: delegationDataInnerConstrData.getAlternative() === BigInt(0) ? 0 : 1
+      };
+      return BaseAddress.fromCredentials(
+        networkId,
+        cardanoPaymentCredential,
+        cardanoStakeCredential
+      ).toAddress().toBech32();
+    } else if (delegationDataInnerConstrData.getAlternative() === BigInt(1)) {
+      const delegationDataInnerList = delegationDataInnerConstrData.getData();
+      if (delegationDataInnerList.getLength() !== 3) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part must contain 3 elements"
+        );
+      }
+      const slot = delegationDataInnerList.get(0).asInteger();
+      if (!slot) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part slot must be integer"
+        );
+      }
+      const txIndex = delegationDataInnerList.get(1).asInteger();
+      if (!txIndex) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part txIndex must be integer"
+        );
+      }
+      const certIndex = delegationDataInnerList.get(2).asInteger();
+      if (!certIndex) {
+        throw new Error(
+          "Error: serializeAddressObj: Delegation inner part certIndex must be integer"
+        );
+      }
+      const cardanoPointer = {
+        slot,
+        txIndex: TxIndex(Number(txIndex)),
+        certIndex: CertIndex(Number(certIndex))
+      };
+      return PointerAddress.fromCredentials(
+        networkId,
+        cardanoPaymentCredential,
+        cardanoPointer
+      ).toAddress().toBech32();
+    } else {
+      throw new Error(
+        "Error: serializeAddressObj: Delegation inner part must be alternative 0 or 1"
+      );
+    }
+  } else {
+    throw new Error(
+      "Error: serializeAddressObj: Delegation part must be alternative 0 or 1"
+    );
+  }
+};
+var serializeAddressObj = (plutusDataAddressObject, networkId = 0) => {
+  const cardanoPlutusData = fromJsonToPlutusData(plutusDataAddressObject);
+  return plutusDataToAddrBech32(cardanoPlutusData, networkId);
+};
+var serializePlutusAddressToBech32 = (plutusHex, networkId = 0) => {
+  const cardanoPlutusData = PlutusData.fromCbor(HexBlob5(plutusHex));
+  return plutusDataToAddrBech32(cardanoPlutusData, networkId);
+};
+var deserializeBech32Address = (bech32Addr) => {
+  const deserializedAddress = Address.fromBech32(bech32Addr).getProps();
+  return {
+    pubKeyHash: deserializedAddress.paymentPart?.type === CredentialType.KeyHash ? deserializedAddress.paymentPart?.hash : "",
+    scriptHash: deserializedAddress.paymentPart?.type === CredentialType.ScriptHash ? deserializedAddress.paymentPart?.hash : "",
+    stakeCredentialHash: deserializedAddress.delegationPart?.type === CredentialType.KeyHash ? deserializedAddress.delegationPart?.hash : "",
+    stakeScriptCredentialHash: deserializedAddress.delegationPart?.type === CredentialType.ScriptHash ? deserializedAddress.delegationPart?.hash : ""
+  };
+};
+var deserializeAddress = (address) => {
+  const _address = Address.fromString(address);
+  if (_address === null) throw new Error("Invalid address");
+  return _address;
+};
+var scriptHashToBech32 = (scriptHash, stakeCredentialHash, networkId = 0, isScriptStakeCredentialHash = false) => {
+  if (stakeCredentialHash) {
+    return BaseAddress.fromCredentials(
+      networkId,
+      { hash: Hash28ByteBase162(scriptHash), type: CredentialType.ScriptHash },
+      {
+        hash: Hash28ByteBase162(stakeCredentialHash),
+        type: isScriptStakeCredentialHash ? CredentialType.ScriptHash : CredentialType.KeyHash
+      }
+    ).toAddress().toBech32().toString();
+  } else {
+    return EnterpriseAddress.fromCredentials(networkId, {
+      hash: Hash28ByteBase162(scriptHash),
+      type: CredentialType.ScriptHash
+    }).toAddress().toBech32().toString();
+  }
+};
+var v2ScriptToBech32 = (scriptCbor, stakeCredential, networkId = 0, isScriptStakeCredential = false) => scriptHashToBech32(
+  Script.fromCbor(HexBlob5(scriptCbor)).hash().toString(),
+  stakeCredential,
+  networkId,
+  isScriptStakeCredential
+);
+var scriptHashToRewardAddress = (hash, networkId = 0) => {
+  return RewardAddress.fromCredentials(networkId, {
+    hash: Hash28ByteBase162(hash),
+    type: CredentialType.ScriptHash
+  }).toAddress().toBech32().toString();
+};
+var keyHashToRewardAddress = (hash, networkId = 0) => {
+  return RewardAddress.fromCredentials(networkId, {
+    hash: Hash28ByteBase162(hash),
+    type: CredentialType.KeyHash
+  }).toAddress().toBech32().toString();
+};
+
+// src/utils/encoding.ts
+import base322 from "base32-encoding";
+import { bech32 as bech322 } from "bech32";
+var bytesToHex = (bytes) => Buffer.from(bytes).toString("hex");
+var hexToBytes = (hex) => Buffer.from(hex, "hex");
+var utf8ToBytes = (str) => Buffer.from(str, "utf8");
+var utf8ToHex = (str) => Buffer.from(str, "utf8").toString("hex");
+var hexToBech32 = (prefix, hex) => {
+  const buf = Buffer.from(hex, "hex");
+  const base32RawBytes = base322.encode(buf);
+  return bech322.encode(prefix, base32RawBytes);
+};
+
+// src/resolvers/index.ts
+var resolveDataHash = (data) => {
+  const plutusData = toPlutusData(data);
+  return plutusData.hash().toString();
+};
+var resolveNativeScriptAddress = (script, networkId = 0) => {
+  const nativeScript = toNativeScript(script);
+  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
+    hash: nativeScript.hash(),
+    type: Cardano2.CredentialType.ScriptHash
+  });
+  return enterpriseAddress.toAddress().toBech32().toString();
+};
+var resolveNativeScriptHash = (script) => {
+  return toNativeScript(script).hash().toString();
+};
+var resolvePaymentKeyHash = (bech325) => {
+  try {
+    const paymentKeyHash = [
+      toBaseAddress(bech325)?.getPaymentCredential().hash,
+      toEnterpriseAddress(bech325)?.getPaymentCredential().hash
+    ].find((kh) => kh !== void 0);
+    if (paymentKeyHash !== void 0) return paymentKeyHash.toString();
+    throw new Error(
+      `Couldn't resolve payment key hash from address: ${bech325}`
+    );
+  } catch (error) {
+    throw new Error(
+      `An error occurred during resolvePaymentKeyHash: ${error}.`
+    );
+  }
+};
+var resolvePlutusScriptAddress = (script, networkId = 0) => {
+  const plutusScript = deserializePlutusScript(script.code, script.version);
+  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
+    hash: plutusScript.hash(),
+    type: Cardano2.CredentialType.ScriptHash
+  });
+  return enterpriseAddress.toAddress().toBech32().toString();
+};
+var resolvePlutusScriptHash = (bech325) => {
+  try {
+    const enterpriseAddress = toEnterpriseAddress(bech325);
+    const scriptHash = enterpriseAddress?.getPaymentCredential().hash;
+    if (scriptHash !== void 0) return scriptHash.toString();
+    throw new Error(`Couldn't resolve script hash from address: ${bech325}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveScriptHash: ${error}.`);
+  }
+};
+var resolvePoolId = (hash) => {
+  return PoolId.fromKeyHash(Ed25519KeyHashHex2(hash)).toString();
+};
+var resolvePrivateKey = (words) => {
+  const buildBip32PrivateKey2 = (entropy2, password = "") => {
+    return Bip32PrivateKey2.fromBip39Entropy(
+      Buffer.from(toBytes4(entropy2)),
+      fromUTF8(password)
+    );
+  };
+  const entropy = mnemonicToEntropy(words.join(" "));
+  const bip32PrivateKey = buildBip32PrivateKey2(entropy);
+  const bytes = base323.encode(bip32PrivateKey.bytes());
+  const bech32PrivateKey = bech323.encode("xprv", bytes, 1023);
+  return bech32PrivateKey;
+};
+var resolveScriptRef = (script) => {
+  return toScriptRef(script).toCbor().toString();
+};
+var resolveRewardAddress = (bech325) => {
+  try {
+    const address = toAddress(bech325);
+    const baseAddress = toBaseAddress(bech325);
+    const stakeKeyHash = baseAddress?.getStakeCredential().hash;
+    if (stakeKeyHash !== void 0)
+      return buildRewardAddress(address.getNetworkId(), stakeKeyHash).toAddress().toBech32().toString();
+    throw new Error(`Couldn't resolve reward address from address: ${bech325}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
+  }
+};
+var resolveStakeKeyHash = (bech325) => {
+  try {
+    const stakeKeyHash = [
+      toBaseAddress(bech325)?.getStakeCredential().hash,
+      toRewardAddress(bech325)?.getPaymentCredential().hash
+    ].find((kh) => kh !== void 0);
+    if (stakeKeyHash !== void 0) return stakeKeyHash.toString();
+    throw new Error(`Couldn't resolve stake key hash from address: ${bech325}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveStakeKeyHash: ${error}.`);
+  }
+};
 var resolveTxHash = (txHex) => {
   const txBody = deserializeTx(txHex).body();
-  const hash = blake2b3(blake2b3.BYTES).update(hexToBytes(txBody.toCbor())).digest();
-  return Cardano2.TransactionId.fromHexBlob(HexBlob4.fromBytes(hash));
+  const hash = blake2b5(blake2b5.BYTES).update(hexToBytes(txBody.toCbor())).digest();
+  return Cardano2.TransactionId.fromHexBlob(HexBlob6.fromBytes(hash)).toString();
+};
+var resolveScriptHashDRepId = (scriptHash) => {
+  return DRepID.cip129FromCredential({
+    type: Cardano2.CredentialType.ScriptHash,
+    hash: Hash28ByteBase162(scriptHash)
+  }).toString();
+};
+var resolveEd25519KeyHash = (bech325) => {
+  try {
+    const keyHash = [
+      toBaseAddress(bech325)?.getPaymentCredential().hash,
+      toEnterpriseAddress(bech325)?.getPaymentCredential().hash
+    ].find((kh) => kh !== void 0);
+    if (keyHash !== void 0) return keyHash.toString();
+    throw new Error(`Couldn't resolve key hash from address: ${bech325}`);
+  } catch (error) {
+    throw new Error(
+      `An error occurred during resolveEd25519KeyHash: ${error}.`
+    );
+  }
 };
 
 // src/serializer/index.ts
-import { Serialization as Serialization4, TxCBOR as TxCBOR2 } from "@cardano-sdk/core";
-import { HexBlob as HexBlob6 } from "@cardano-sdk/util";
+import { Serialization as Serialization6 } from "@cardano-sdk/core";
+import { HexBlob as HexBlob8 } from "@cardano-sdk/util";
 import {
+  Cbor,
+  CborArray,
+  CborBytes,
+  CborString,
+  CborTag,
+  CborUInt
+} from "@harmoniclabs/cbor";
+import base324 from "base32-encoding";
+import { bech32 as bech324 } from "bech32";
+import {
+  DEFAULT_PROTOCOL_PARAMETERS,
   DEFAULT_V1_COST_MODEL_LIST,
-  DEFAULT_V2_COST_MODEL_LIST
+  DEFAULT_V2_COST_MODEL_LIST,
+  DEFAULT_V3_COST_MODEL_LIST,
+  fromUTF8 as fromUTF82,
+  mnemonicToEntropy as mnemonicToEntropy2,
+  toBytes as toBytes5
 } from "@meshsdk/common";
 
+// src/utils/certificate.ts
+import { Cardano as Cardano3, Serialization as Serialization4 } from "@cardano-sdk/core";
+var toCardanoCert = (cert) => {
+  switch (cert.type) {
+    case "RegisterPool": {
+      let relays = [];
+      for (const relay of cert.poolParams.relays) {
+        switch (relay.type) {
+          case "SingleHostAddr": {
+            relays.push(
+              Serialization4.Relay.newSingleHostAddr(
+                new Serialization4.SingleHostAddr(
+                  relay.port,
+                  relay.IPV4,
+                  relay.IPV6
+                )
+              )
+            );
+            break;
+          }
+          case "SingleHostName": {
+            relays.push(
+              Serialization4.Relay.newSingleHostName(
+                new Serialization4.SingleHostName(relay.domainName, relay.port)
+              )
+            );
+            break;
+          }
+          case "MultiHostName": {
+            relays.push(
+              Serialization4.Relay.newMultiHostName(
+                new Serialization4.MultiHostName(relay.domainName)
+              )
+            );
+            break;
+          }
+        }
+      }
+      let poolOwners = Serialization4.CborSet.fromCore([], Serialization4.Hash.fromCore);
+      let poolOwnersValues = [...poolOwners.values()];
+      for (const poolOwner of cert.poolParams.owners) {
+        poolOwnersValues.push(
+          Serialization4.Hash.fromCore(Ed25519KeyHashHex2(poolOwner))
+        );
+      }
+      poolOwners.setValues(poolOwnersValues);
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.poolParams.rewardAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      const metadata = cert.poolParams.metadata ? new Serialization4.PoolMetadata(
+        cert.poolParams.metadata.URL,
+        Crypto2.Hash32ByteBase16(cert.poolParams.metadata.hash)
+      ) : void 0;
+      return Certificate.newPoolRegistration(
+        new Serialization4.PoolRegistration(
+          new Serialization4.PoolParams(
+            Ed25519KeyHashHex2(cert.poolParams.operator),
+            Cardano3.VrfVkHex(cert.poolParams.vrfKeyHash),
+            BigInt(cert.poolParams.pledge),
+            BigInt(cert.poolParams.cost),
+            new Serialization4.UnitInterval(
+              BigInt(cert.poolParams.margin[0]),
+              BigInt(cert.poolParams.margin[1])
+            ),
+            rewardAddress,
+            poolOwners,
+            relays,
+            metadata
+          )
+        )
+      );
+    }
+    case "RegisterStake": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      return Certificate.newStakeRegistration(
+        new Serialization4.StakeRegistration(
+          rewardAddress.getPaymentCredential()
+        )
+      );
+    }
+    case "DelegateStake": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      return Certificate.newStakeDelegation(
+        new Serialization4.StakeDelegation(
+          rewardAddress.getPaymentCredential(),
+          Ed25519KeyHashHex2(cert.poolId)
+        )
+      );
+    }
+    case "DeregisterStake": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      return Certificate.newStakeDeregistration(
+        new Serialization4.StakeDeregistration(
+          rewardAddress.getPaymentCredential()
+        )
+      );
+    }
+    case "RetirePool": {
+      return Certificate.newPoolRetirement(
+        new Serialization4.PoolRetirement(
+          Ed25519KeyHashHex2(cert.poolId),
+          Cardano3.EpochNo(cert.epoch)
+        )
+      );
+    }
+    case "VoteDelegation": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      if (cert.drep.dRepId !== void 0) {
+        return Certificate.newVoteDelegationCert(
+          new Serialization4.VoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            toDRep(cert.drep.dRepId)
+          )
+        );
+      } else if (cert.drep.alwaysAbstain !== void 0) {
+        return Certificate.newVoteDelegationCert(
+          new Serialization4.VoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysAbstain()
+          )
+        );
+      } else if (cert.drep.alwaysNoConfidence !== void 0) {
+        return Certificate.newVoteDelegationCert(
+          new Serialization4.VoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysNoConfidence()
+          )
+        );
+      } else {
+        throw new Error("Malformed DRep type");
+      }
+    }
+    case "StakeAndVoteDelegation": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      if (cert.drep.dRepId !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            toDRep(cert.drep.dRepId),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else if (cert.drep.alwaysAbstain !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysAbstain(),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else if (cert.drep.alwaysNoConfidence !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysNoConfidence(),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else {
+        throw new Error("Malformed DRep type");
+      }
+    }
+    case "StakeRegistrationAndDelegation": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      return Certificate.newStakeRegistrationDelegationCert(
+        new Serialization4.StakeRegistrationDelegation(
+          rewardAddress.getPaymentCredential(),
+          BigInt(cert.coin),
+          Ed25519KeyHashHex2(cert.poolKeyHash)
+        )
+      );
+    }
+    case "VoteRegistrationAndDelegation": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      if (cert.drep.dRepId !== void 0) {
+        return Certificate.newVoteRegistrationDelegationCert(
+          new Serialization4.VoteRegistrationDelegation(
+            rewardAddress.getPaymentCredential(),
+            BigInt(cert.coin),
+            toDRep(cert.drep.dRepId)
+          )
+        );
+      } else if (cert.drep.alwaysAbstain !== void 0) {
+        return Certificate.newVoteRegistrationDelegationCert(
+          new Serialization4.VoteRegistrationDelegation(
+            rewardAddress.getPaymentCredential(),
+            BigInt(cert.coin),
+            Serialization4.DRep.newAlwaysAbstain()
+          )
+        );
+      } else if (cert.drep.alwaysNoConfidence !== void 0) {
+        return Certificate.newVoteRegistrationDelegationCert(
+          new Serialization4.VoteRegistrationDelegation(
+            rewardAddress.getPaymentCredential(),
+            BigInt(cert.coin),
+            Serialization4.DRep.newAlwaysNoConfidence()
+          )
+        );
+      } else {
+        throw new Error("Malformed DRep type");
+      }
+    }
+    case "StakeVoteRegistrationAndDelegation": {
+      const rewardAddress = Cardano3.RewardAddress.fromAddress(
+        Cardano3.Address.fromBech32(cert.stakeKeyAddress)
+      );
+      if (rewardAddress === void 0) {
+        throw new Error(
+          "Error parsing reward address, it is expected to be in bech32 format"
+        );
+      }
+      if (cert.drep.dRepId !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            toDRep(cert.drep.dRepId),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else if (cert.drep.alwaysAbstain !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysAbstain(),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else if (cert.drep.alwaysNoConfidence !== void 0) {
+        return Certificate.newStakeVoteDelegationCert(
+          new Serialization4.StakeVoteDelegation(
+            rewardAddress.getPaymentCredential(),
+            Serialization4.DRep.newAlwaysNoConfidence(),
+            Ed25519KeyHashHex2(cert.poolKeyHash)
+          )
+        );
+      } else {
+        throw new Error("Malformed DRep type");
+      }
+    }
+    case "CommitteeHotAuth": {
+      const hotCred = Cardano3.Address.fromBech32(
+        cert.committeeHotKeyAddress
+      ).getProps().paymentPart;
+      const coldCred = Cardano3.Address.fromBech32(
+        cert.committeeColdKeyAddress
+      ).getProps().paymentPart;
+      if (!hotCred || !coldCred) {
+        throw new Error("Malformed hot/cold credential");
+      }
+      return Certificate.newAuthCommitteeHotCert(
+        new Serialization4.AuthCommitteeHot(coldCred, hotCred)
+      );
+    }
+    case "CommitteeColdResign": {
+      const coldCred = Cardano3.Address.fromBech32(
+        cert.committeeColdKeyAddress
+      ).getProps().paymentPart;
+      if (!coldCred) {
+        throw new Error("Malformed hot/cold credential");
+      }
+      let anchor = void 0;
+      if (cert.anchor) {
+        anchor = new Serialization4.Anchor(
+          cert.anchor.anchorUrl,
+          Hash32ByteBase162(cert.anchor.anchorDataHash)
+        );
+      }
+      return Certificate.newResignCommitteeColdCert(
+        new Serialization4.ResignCommitteeCold(coldCred, anchor)
+      );
+    }
+    case "DRepRegistration": {
+      let anchor = void 0;
+      if (cert.anchor) {
+        anchor = new Serialization4.Anchor(
+          cert.anchor.anchorUrl,
+          Hash32ByteBase162(cert.anchor.anchorDataHash)
+        );
+      }
+      const coreDRep = toDRep(cert.drepId).toCore();
+      if (Cardano3.isDRepCredential(coreDRep)) {
+        return Certificate.newRegisterDelegateRepresentativeCert(
+          new Serialization4.RegisterDelegateRepresentative(
+            coreDRep,
+            BigInt(cert.coin),
+            anchor
+          )
+        );
+      } else {
+        throw new Error("DRepId must be a Credential");
+      }
+    }
+    case "DRepDeregistration": {
+      const coreDRep = toDRep(cert.drepId).toCore();
+      if (Cardano3.isDRepCredential(coreDRep)) {
+        return Certificate.newUnregisterDelegateRepresentativeCert(
+          new Serialization4.UnregisterDelegateRepresentative(
+            coreDRep,
+            BigInt(cert.coin)
+          )
+        );
+      } else {
+        throw new Error("DRepId must be a Credential");
+      }
+    }
+    case "DRepUpdate": {
+      let anchor = void 0;
+      if (cert.anchor) {
+        anchor = new Serialization4.Anchor(
+          cert.anchor.anchorUrl,
+          Hash32ByteBase162(cert.anchor.anchorDataHash)
+        );
+      }
+      const coreDRep = toDRep(cert.drepId).toCore();
+      if (Cardano3.isDRepCredential(coreDRep)) {
+        return Certificate.newUpdateDelegateRepresentativeCert(
+          new Serialization4.UpdateDelegateRepresentative(coreDRep, anchor)
+        );
+      } else {
+        throw new Error("DRepId must be a Credential");
+      }
+    }
+  }
+};
+
+// src/utils/fee.ts
+var calculateFees = (minFeeA, minFeeB, minFeeRefScriptCostPerByte, priceMem, priceStep, tx, refScriptSize) => {
+  let fee = minFeeB + tx.toCbor().length / 2 * minFeeA;
+  const tierSize = 25600;
+  let currentRefScriptSize = refScriptSize;
+  let multiplier = 1.2;
+  while (currentRefScriptSize >= tierSize) {
+    fee += tierSize * multiplier * minFeeRefScriptCostPerByte;
+    currentRefScriptSize -= tierSize;
+    multiplier *= multiplier;
+  }
+  if (currentRefScriptSize > 0) {
+    fee += currentRefScriptSize * multiplier * minFeeRefScriptCostPerByte;
+  }
+  let scriptFee = BigInt(0);
+  let priceMemNumerator = priceMem;
+  let priceMemDenominator = 1;
+  while (priceMemNumerator % 1) {
+    priceMemNumerator *= 10;
+    priceMemDenominator *= 10;
+  }
+  let priceStepNumerator = priceStep;
+  let priceStepDenominator = 1;
+  while (priceStepNumerator % 1) {
+    priceStepNumerator *= 10;
+    priceStepDenominator *= 10;
+  }
+  if (tx.witnessSet().redeemers()) {
+    for (const redeemer of tx.witnessSet().redeemers().values()) {
+      scriptFee += redeemer.exUnits().mem() * BigInt(priceMemNumerator.toString()) / BigInt(priceMemDenominator.toString()) + BigInt(1);
+      scriptFee += redeemer.exUnits().steps() * BigInt(priceStepNumerator.toString()) / BigInt(priceStepDenominator.toString()) + BigInt(1);
+    }
+  }
+  return BigInt(fee) + scriptFee;
+};
+
+// src/utils/metadata.ts
+var toCardanoMetadataMap = (metadata) => {
+  let cardanoMetadataMap = /* @__PURE__ */ new Map();
+  metadata.forEach((val, key) => {
+    cardanoMetadataMap.set(key, toCardanoMetadatum(val));
+  });
+  return cardanoMetadataMap;
+};
+var toCardanoMetadatum = (metadatum) => {
+  if (typeof metadatum === "number") {
+    return TransactionMetadatum.newInteger(BigInt(metadatum));
+  } else if (typeof metadatum === "string") {
+    return TransactionMetadatum.newText(metadatum);
+  } else if (typeof metadatum === "bigint") {
+    return TransactionMetadatum.newInteger(metadatum);
+  } else if (metadatum instanceof Uint8Array) {
+    return TransactionMetadatum.newBytes(metadatum);
+  } else if (metadatum instanceof Map) {
+    const result = new MetadatumMap();
+    metadatum.forEach((value, key) => {
+      result.insert(toCardanoMetadatum(key), toCardanoMetadatum(value));
+    });
+    return TransactionMetadatum.newMap(result);
+  } else if (Array.isArray(metadatum)) {
+    const result = new MetadatumList();
+    metadatum.forEach((val) => {
+      result.add(toCardanoMetadatum(val));
+    });
+    return TransactionMetadatum.newList(result);
+  } else {
+    throw new Error("metadatumToObj: Unsupported Metadatum type");
+  }
+};
+
 // src/utils/script-data-hash.ts
-import { Serialization as Serialization3 } from "@cardano-sdk/core";
-import * as Crypto2 from "@cardano-sdk/crypto";
+import { Serialization as Serialization5 } from "@cardano-sdk/core";
+import * as Crypto3 from "@cardano-sdk/crypto";
 import { Hash32ByteBase16 as Hash32ByteBase163 } from "@cardano-sdk/crypto";
-import { HexBlob as HexBlob5 } from "@cardano-sdk/util";
+import { HexBlob as HexBlob7 } from "@cardano-sdk/util";
 var CBOR_EMPTY_LIST = new Uint8Array([128]);
 var CBOR_EMPTY_MAP = new Uint8Array([160]);
 var getCborEncodedArray = (items) => {
-  const writer = new Serialization3.CborWriter();
+  const writer = new Serialization5.CborWriter();
   writer.writeStartArray(items.length);
   for (const item of items) {
     writer.writeEncodedValue(Buffer.from(item.toCbor(), "hex"));
@@ -1833,7 +2913,7 @@ var getCborEncodedArray = (items) => {
   return writer.encode();
 };
 var hashScriptData = (costModels, redemeers, datums) => {
-  const writer = new Serialization3.CborWriter();
+  const writer = new Serialization5.CborWriter();
   if (datums && datums.length > 0 && (!redemeers || redemeers.length === 0)) {
     writer.writeEncodedValue(CBOR_EMPTY_LIST);
     writer.writeEncodedValue(getCborEncodedArray(datums));
@@ -1848,8 +2928,8 @@ var hashScriptData = (costModels, redemeers, datums) => {
     );
   }
   return Hash32ByteBase163.fromHexBlob(
-    HexBlob5.fromBytes(
-      Crypto2.blake2b(Crypto2.blake2b.BYTES).update(writer.encode()).digest()
+    HexBlob7.fromBytes(
+      Crypto3.blake2b(Crypto3.blake2b.BYTES).update(writer.encode()).digest()
     )
   );
 };
@@ -1857,148 +2937,253 @@ var hashScriptData = (costModels, redemeers, datums) => {
 // src/serializer/index.ts
 var CardanoSDKSerializer = class {
   verbose;
-  txBody;
-  txWitnessSet;
-  utxoContext = /* @__PURE__ */ new Map();
-  redeemerContext = /* @__PURE__ */ new Map();
-  scriptsProvided = /* @__PURE__ */ new Set();
-  datumsProvided = /* @__PURE__ */ new Set();
-  usedLanguages = {
-    [0]: false,
-    [1]: false,
-    [2]: false
-  };
-  constructor(verbose = false) {
+  protocolParams;
+  constructor(protocolParams, verbose = false) {
+    this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
     this.verbose = verbose;
-    this.txBody = new TransactionBody(
-      Serialization4.CborSet.fromCore([], TransactionInput.fromCore),
-      [],
-      BigInt(0),
-      void 0
-    );
-    this.txWitnessSet = new TransactionWitnessSet();
   }
   serializeRewardAddress(stakeKeyHash, isScriptHash, network_id) {
-    throw new Error("Method not implemented.");
+    return RewardAddress.fromCredentials(network_id ?? 0, {
+      type: isScriptHash ? CredentialType.ScriptHash : CredentialType.KeyHash,
+      hash: Hash28ByteBase162(stakeKeyHash)
+    }).toAddress().toBech32();
   }
   serializePoolId(hash) {
-    throw new Error("Method not implemented.");
+    return PoolId.fromKeyHash(Ed25519KeyHashHex2(hash)).toString();
   }
   serializeAddress(address, networkId) {
-    throw new Error("Method not implemented.");
+    let paymentCred = void 0;
+    let stakeCred;
+    if (address.pubKeyHash && address.pubKeyHash !== "") {
+      paymentCred = {
+        type: CredentialType.KeyHash,
+        hash: Hash28ByteBase162(address.pubKeyHash)
+      };
+    } else if (address.scriptHash && address.scriptHash !== "") {
+      paymentCred = {
+        type: CredentialType.ScriptHash,
+        hash: Hash28ByteBase162(address.scriptHash)
+      };
+    }
+    if (address.stakeCredentialHash && address.stakeCredentialHash !== "") {
+      stakeCred = {
+        type: CredentialType.KeyHash,
+        hash: Hash28ByteBase162(address.stakeCredentialHash)
+      };
+    } else if (address.stakeScriptCredentialHash) {
+      stakeCred = {
+        type: CredentialType.ScriptHash,
+        hash: Hash28ByteBase162(address.stakeScriptCredentialHash)
+      };
+    }
+    let type = AddressType.BasePaymentKeyStakeKey;
+    if (paymentCred && stakeCred) {
+      if (paymentCred.type === CredentialType.KeyHash && stakeCred.type === CredentialType.KeyHash) {
+        type = AddressType.BasePaymentKeyStakeKey;
+      } else if (paymentCred.type === CredentialType.KeyHash && stakeCred.type === CredentialType.ScriptHash) {
+        type = AddressType.BasePaymentKeyStakeScript;
+      } else if (paymentCred.type === CredentialType.ScriptHash && stakeCred.type === CredentialType.KeyHash) {
+        type = AddressType.BasePaymentScriptStakeKey;
+      } else if (paymentCred.type === CredentialType.ScriptHash && stakeCred.type === CredentialType.ScriptHash) {
+        type = AddressType.BasePaymentScriptStakeScript;
+      }
+    } else if (paymentCred) {
+      if (paymentCred.type === CredentialType.KeyHash) {
+        type = AddressType.EnterpriseKey;
+      } else if (paymentCred.type === CredentialType.ScriptHash) {
+        type = AddressType.EnterpriseScript;
+      }
+    } else if (stakeCred) {
+      if (stakeCred.type === CredentialType.KeyHash) {
+        type = AddressType.RewardKey;
+      } else if (stakeCred.type === CredentialType.ScriptHash) {
+        type = AddressType.RewardScript;
+      }
+    }
+    return new Address({
+      type,
+      networkId: networkId ?? 0,
+      paymentPart: paymentCred,
+      delegationPart: stakeCred
+    }).toBech32();
   }
   serializeData(data) {
-    throw new Error("Method not implemented.");
+    const plutusData = fromBuilderToPlutusData(data);
+    return plutusData.toCbor().toString();
   }
   deserializer = {
     key: {
-      deserializeAddress: function(bech32) {
-        throw new Error("Function not implemented.");
+      deserializeAddress: function(bech325) {
+        const address = Address.fromBech32(bech325);
+        const addressProps = address.getProps();
+        return {
+          pubKeyHash: addressProps.paymentPart?.type === CredentialType.KeyHash ? addressProps.paymentPart?.hash ?? "" : "",
+          scriptHash: addressProps.paymentPart?.type === CredentialType.ScriptHash ? addressProps.paymentPart?.hash ?? "" : "",
+          stakeCredentialHash: addressProps.delegationPart?.type === CredentialType.KeyHash ? addressProps.paymentPart?.hash ?? "" : "",
+          stakeScriptCredentialHash: addressProps.delegationPart?.type === CredentialType.ScriptHash ? addressProps.paymentPart?.hash ?? "" : ""
+        };
       }
     },
     script: {
       deserializeNativeScript: function(script) {
-        throw new Error("Function not implemented.");
+        const cardanoNativeScript = toNativeScript(script);
+        return {
+          scriptHash: cardanoNativeScript.hash().toString(),
+          scriptCbor: cardanoNativeScript.toCbor().toString()
+        };
       },
       deserializePlutusScript: function(script) {
-        throw new Error("Function not implemented.");
+        let cardanoPlutusScript;
+        switch (script.version) {
+          case "V1": {
+            cardanoPlutusScript = new PlutusV1Script(HexBlob8(script.code));
+            break;
+          }
+          case "V2": {
+            cardanoPlutusScript = new PlutusV2Script(HexBlob8(script.code));
+            break;
+          }
+          case "V3": {
+            cardanoPlutusScript = new PlutusV3Script(HexBlob8(script.code));
+            break;
+          }
+        }
+        return {
+          scriptHash: cardanoPlutusScript.hash().toString(),
+          scriptCbor: cardanoPlutusScript.toCbor().toString()
+        };
       }
     },
     cert: {
       deserializePoolId: function(poolId) {
-        throw new Error("Function not implemented.");
+        const cardanoPoolId = PoolId(poolId);
+        return PoolId.toKeyHash(cardanoPoolId).toString();
       }
     }
   };
   resolver = {
     keys: {
-      // resolvePaymentKeyHash: function (bech32: string): string {
-      //   const cardanoAddress = toAddress(bech32);
-      //   return cardanoAddress.asEnterprise()?.getPaymentCredential().type ===
-      //     CredentialType.KeyHash
-      //     ? cardanoAddress.asEnterprise()!.getPaymentCredential().hash
-      //     : "";
-      // },
-      // resolvePlutusScriptHash: function (bech32: string): string {
-      //   const cardanoAddress = toAddress(bech32);
-      //   return cardanoAddress.asEnterprise()?.getPaymentCredential().type ===
-      //     CredentialType.ScriptHash
-      //     ? cardanoAddress.asEnterprise()!.getPaymentCredential().hash
-      //     : "";
-      // },
-      resolveStakeKeyHash: function(bech32) {
-        const cardanoAddress = toAddress(bech32);
+      resolveStakeKeyHash: function(bech325) {
+        const cardanoAddress = toAddress(bech325);
         return cardanoAddress.asReward()?.getPaymentCredential().type === CredentialType.KeyHash ? cardanoAddress.asReward().getPaymentCredential().hash : "";
       },
-      // resolveStakeScriptHash(bech32: string): string {
-      //   const cardanoAddress = toAddress(bech32);
-      //   return cardanoAddress.asReward()?.getPaymentCredential().type ===
-      //     CredentialType.ScriptHash
-      //     ? cardanoAddress.asReward()!.getPaymentCredential().hash
-      //     : "";
-      // },
       resolvePrivateKey: function(words) {
-        throw new Error("Function not implemented.");
+        const buildBip32PrivateKey2 = (entropy2, password = "") => {
+          return Bip32PrivateKey2.fromBip39Entropy(
+            Buffer.from(toBytes5(entropy2)),
+            fromUTF82(password)
+          );
+        };
+        const entropy = mnemonicToEntropy2(words.join(" "));
+        const bip32PrivateKey = buildBip32PrivateKey2(entropy);
+        const bytes = base324.encode(bip32PrivateKey.bytes());
+        const bech32PrivateKey = bech324.encode("xprv", bytes, 1023);
+        return bech32PrivateKey;
       },
-      resolveRewardAddress: function(bech32) {
-        throw new Error("Function not implemented.");
+      resolveRewardAddress: function(bech325) {
+        const cardanoAddress = toAddress(bech325);
+        const addressProps = cardanoAddress.getProps();
+        if (!addressProps.delegationPart) {
+          return "";
+        }
+        return RewardAddress.fromCredentials(
+          cardanoAddress.getNetworkId(),
+          addressProps.delegationPart
+        ).toAddress().toBech32() ?? "";
       },
-      resolveEd25519KeyHash: function(bech32) {
-        throw new Error("Function not implemented.");
+      resolveEd25519KeyHash: function(bech325) {
+        const cardanoAddress = toAddress(bech325);
+        const addressProps = cardanoAddress.getProps();
+        if (!addressProps.paymentPart) {
+          return "";
+        }
+        return addressProps.paymentPart.hash.toString();
       }
     },
     tx: {
       resolveTxHash: function(txHex) {
-        return Transaction.fromCbor(TxCBOR2(txHex)).getId();
+        return Transaction.fromCbor(Serialization6.TxCBOR(txHex)).getId();
       }
     },
     data: {
       resolveDataHash: function(data) {
-        throw new Error("Function not implemented.");
+        return fromBuilderToPlutusData({ type: "Mesh", content: data }).hash();
       }
     },
     script: {
-      // resolveNativeScript: function (script: CommonNativeScript): string {
-      //   return toNativeScript(script).toCbor();
-      // },
       resolveScriptRef: function(script) {
-        throw new Error("Function not implemented.");
+        if ("code" in script) {
+          let versionByte;
+          switch (script.version) {
+            case "V1": {
+              versionByte = 1;
+              break;
+            }
+            case "V2": {
+              versionByte = 2;
+              break;
+            }
+            case "V3": {
+              versionByte = 3;
+              break;
+            }
+          }
+          let taggedScript = new CborTag(
+            24,
+            Cbor.parse(
+              CborString.fromCborObj(
+                new CborBytes(
+                  Cbor.encode(
+                    new CborArray([
+                      new CborUInt(versionByte),
+                      new CborString(script.code).toCborObj()
+                    ])
+                  ).toBuffer()
+                )
+              )
+            )
+          );
+          return Cbor.encode(taggedScript).toString();
+        } else {
+          const nativeScript = toNativeScript(script);
+          let taggedScript = new CborTag(
+            24,
+            Cbor.parse(
+              CborString.fromCborObj(
+                new CborBytes(
+                  Cbor.encode(
+                    new CborArray([
+                      new CborUInt(0),
+                      new CborString(nativeScript.toCbor()).toCborObj()
+                    ])
+                  ).toBuffer()
+                )
+              )
+            )
+          );
+          return Cbor.encode(taggedScript).toString();
+        }
       }
     }
   };
   serializeTxBody = (txBuilderBody, protocolParams) => {
-    const {
-      inputs,
-      outputs,
-      collaterals,
-      referenceInputs,
-      mints,
-      changeAddress,
-      // certificates,
-      validityRange,
-      requiredSignatures
-      // metadata,
-    } = txBuilderBody;
-    mints.sort((a, b) => a.policyId.localeCompare(b.policyId));
-    inputs.sort((a, b) => {
-      if (a.txIn.txHash === b.txIn.txHash) {
-        return a.txIn.txIndex - b.txIn.txIndex;
-      } else {
-        return a.txIn.txHash.localeCompare(b.txIn.txHash);
-      }
-    });
-    this.addAllInputs(inputs);
-    this.addAllOutputs(outputs);
-    this.addAllMints(mints);
-    this.addAllCollateralInputs(collaterals);
-    this.addAllReferenceInputs(referenceInputs);
-    this.setValidityInterval(validityRange);
-    this.buildWitnessSet();
-    this.balanceTx(changeAddress, requiredSignatures.length, protocolParams);
-    return new Transaction(this.txBody, this.txWitnessSet).toCbor();
+    if (this.verbose) {
+      console.log(
+        "txBodyJson",
+        JSON.stringify(txBuilderBody, (key, val) => {
+          if (key === "extraInputs") return void 0;
+          if (key === "selectionConfig") return void 0;
+          return val;
+        })
+      );
+    }
+    const serializerCore = new CardanoSDKSerializerCore(
+      protocolParams ?? this.protocolParams
+    );
+    return serializerCore.coreSerializeTxBody(txBuilderBody);
   };
   addSigningKeys = (txHex, signingKeys) => {
-    let cardanoTx = Transaction.fromCbor(TxCBOR2(txHex));
+    let cardanoTx = Transaction.fromCbor(Serialization6.TxCBOR(txHex));
     let currentWitnessSet = cardanoTx.witnessSet();
     let currentWitnessSetVkeys = currentWitnessSet.vkeys();
     let currentWitnessSetVkeysValues = currentWitnessSetVkeys ? [...currentWitnessSetVkeys.values()] : [];
@@ -2025,7 +3210,7 @@ var CardanoSDKSerializer = class {
       }
     }
     currentWitnessSet.setVkeys(
-      Serialization4.CborSet.fromCore(
+      Serialization6.CborSet.fromCore(
         currentWitnessSetVkeysValues.map((vkw) => vkw.toCore()),
         VkeyWitness.fromCore
       )
@@ -2033,6 +3218,103 @@ var CardanoSDKSerializer = class {
     cardanoTx.setWitnessSet(currentWitnessSet);
     return cardanoTx.toCbor();
   };
+};
+var CardanoSDKSerializerCore = class {
+  txBody;
+  txWitnessSet;
+  txAuxilliaryData;
+  utxoContext = /* @__PURE__ */ new Map();
+  mintRedeemers = /* @__PURE__ */ new Map();
+  scriptsProvided = /* @__PURE__ */ new Set();
+  datumsProvided = /* @__PURE__ */ new Set();
+  usedLanguages = {
+    [0]: false,
+    [1]: false,
+    [2]: false
+  };
+  protocolParams;
+  refScriptSize;
+  constructor(protocolParams) {
+    this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
+    this.txBody = new TransactionBody(
+      Serialization6.CborSet.fromCore([], TransactionInput.fromCore),
+      [],
+      BigInt(0),
+      void 0
+    );
+    this.refScriptSize = 0;
+    this.txWitnessSet = new TransactionWitnessSet();
+    this.txAuxilliaryData = new AuxilliaryData();
+  }
+  coreSerializeTxBody = (txBuilderBody) => {
+    const {
+      inputs,
+      outputs,
+      collaterals,
+      requiredSignatures,
+      referenceInputs,
+      mints,
+      changeAddress,
+      metadata,
+      validityRange,
+      certificates,
+      withdrawals
+    } = txBuilderBody;
+    this.addAllInputs(inputs);
+    this.addAllOutputs(this.sanitizeOutputs(outputs));
+    this.addAllMints(mints);
+    this.addAllCerts(certificates);
+    this.addAllWithdrawals(withdrawals);
+    this.addAllCollateralInputs(collaterals);
+    this.addAllReferenceInputs(referenceInputs);
+    this.removeInputRefInputOverlap();
+    this.setValidityInterval(validityRange);
+    this.addAllRequiredSignatures(requiredSignatures);
+    if (metadata.size > 0) {
+      this.addMetadata(metadata);
+    }
+    this.buildWitnessSet();
+    this.balanceTx(changeAddress);
+    return new Transaction(
+      this.txBody,
+      this.txWitnessSet,
+      this.txAuxilliaryData
+    ).toCbor();
+  };
+  sanitizeOutputs = (outputs) => {
+    for (let i = 0; i < outputs.length; i++) {
+      let currentOutput = outputs[i];
+      let lovelaceFound = false;
+      for (let j = 0; j < currentOutput.amount.length; j++) {
+        let outputAmount = currentOutput.amount[j];
+        if (outputAmount?.unit == "" || outputAmount?.unit == "lovelace") {
+          lovelaceFound = true;
+          if (outputAmount?.quantity == "0" || outputAmount?.quantity == "") {
+            outputAmount.unit = "lovelace";
+            outputAmount.quantity = "10000000";
+            let dummyCardanoOutput = this.toCardanoOutput(
+              currentOutput
+            );
+            let minUtxoValue = (160 + dummyCardanoOutput.toCbor().length / 2 + 1) * this.protocolParams.coinsPerUtxoSize;
+            outputAmount.quantity = minUtxoValue.toString();
+          }
+        }
+        if (!lovelaceFound) {
+          let currentAmount = {
+            unit: "lovelace",
+            quantity: "10000000"
+          };
+          currentOutput.amount.push(currentAmount);
+          let dummyCardanoOutput = this.toCardanoOutput(
+            currentOutput
+          );
+          let minUtxoValue = (160 + dummyCardanoOutput.toCbor().length / 2 + 1) * this.protocolParams.coinsPerUtxoSize;
+          currentAmount.quantity = minUtxoValue.toString();
+        }
+      }
+    }
+    return outputs;
+  };
   addAllInputs = (inputs) => {
     for (let i = 0; i < inputs.length; i += 1) {
       const currentTxIn = inputs[i];
@@ -2043,7 +3325,8 @@ var CardanoSDKSerializer = class {
           break;
         case "Script":
           this.addScriptTxIn(
-            currentTxIn
+            currentTxIn,
+            i
           );
           break;
         case "SimpleScript":
@@ -2068,13 +3351,13 @@ var CardanoSDKSerializer = class {
     txInputsList.push(cardanoTxIn);
     inputs.setValues(txInputsList);
     const cardanoTxOut = new TransactionOutput(
-      Address.fromBech32(currentTxIn.txIn.address),
+      toCardanoAddress(currentTxIn.txIn.address),
       toValue(currentTxIn.txIn.amount)
     );
     this.utxoContext.set(cardanoTxIn, cardanoTxOut);
     this.txBody.setInputs(inputs);
   };
-  addScriptTxIn = (currentTxIn) => {
+  addScriptTxIn = (currentTxIn, index) => {
     this.addTxIn({
       type: "PubKey",
       txIn: currentTxIn.txIn
@@ -2089,74 +3372,16 @@ var CardanoSDKSerializer = class {
       throw new Error("A script input had no redeemer");
     }
     if (currentTxIn.scriptTxIn.scriptSource.type === "Provided") {
-      switch (currentTxIn.scriptTxIn.scriptSource.script.version) {
-        case "V1": {
-          this.scriptsProvided.add(
-            Script.newPlutusV1Script(
-              PlutusV1Script.fromCbor(
-                HexBlob6(currentTxIn.scriptTxIn.scriptSource.script.code)
-              )
-            )
-          );
-          this.usedLanguages[PlutusLanguageVersion.V1] = true;
-          break;
-        }
-        case "V2": {
-          this.scriptsProvided.add(
-            Script.newPlutusV2Script(
-              PlutusV2Script.fromCbor(
-                HexBlob6(currentTxIn.scriptTxIn.scriptSource.script.code)
-              )
-            )
-          );
-          this.usedLanguages[PlutusLanguageVersion.V2] = true;
-          break;
-        }
-        case "V3": {
-          this.scriptsProvided.add(
-            Script.newPlutusV3Script(
-              PlutusV3Script.fromCbor(
-                HexBlob6(currentTxIn.scriptTxIn.scriptSource.script.code)
-              )
-            )
-          );
-          this.usedLanguages[PlutusLanguageVersion.V3] = true;
-          break;
-        }
-      }
+      this.addProvidedPlutusScript(currentTxIn.scriptTxIn.scriptSource.script);
     } else if (currentTxIn.scriptTxIn.scriptSource.type === "Inline") {
-      let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
-      let referenceInputsList = [...referenceInputs.values()];
-      referenceInputsList.push(
-        new TransactionInput(
-          TransactionId(currentTxIn.scriptTxIn.scriptSource.txHash),
-          BigInt(currentTxIn.scriptTxIn.scriptSource.txIndex)
-        )
-      );
-      referenceInputs.setValues(referenceInputsList);
-      this.txBody.setReferenceInputs(referenceInputs);
-      switch (currentTxIn.scriptTxIn.scriptSource.version) {
-        case "V1": {
-          this.usedLanguages[PlutusLanguageVersion.V1] = true;
-          break;
-        }
-        case "V2": {
-          this.usedLanguages[PlutusLanguageVersion.V2] = true;
-          break;
-        }
-        case "V3": {
-          this.usedLanguages[PlutusLanguageVersion.V3] = true;
-          break;
-        }
-      }
+      this.addScriptRef(currentTxIn.scriptTxIn.scriptSource);
     }
     if (currentTxIn.scriptTxIn.datumSource.type === "Provided") {
       this.datumsProvided.add(
-        toPlutusData(currentTxIn.scriptTxIn.datumSource.data.content)
-        // TODO: handle json / raw datum
+        fromBuilderToPlutusData(currentTxIn.scriptTxIn.datumSource.data)
       );
     } else if (currentTxIn.scriptTxIn.datumSource.type === "Inline") {
-      let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
+      let referenceInputs = this.txBody.referenceInputs() ?? Serialization6.CborSet.fromCore([], TransactionInput.fromCore);
       let referenceInputsList = [...referenceInputs.values()];
       referenceInputsList.push(
         new TransactionInput(
@@ -2167,21 +3392,19 @@ var CardanoSDKSerializer = class {
       referenceInputs.setValues(referenceInputsList);
       this.txBody.setReferenceInputs(referenceInputs);
     }
-    let cardanoTxIn = new TransactionInput(
-      TransactionId(currentTxIn.txIn.txHash),
-      BigInt(currentTxIn.txIn.txIndex)
-    );
     let exUnits = currentTxIn.scriptTxIn.redeemer.exUnits;
-    this.redeemerContext.set(
-      cardanoTxIn,
+    let redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
+    let redeemersList = [...redeemers.values()];
+    redeemersList.push(
       new Redeemer(
         RedeemerTag.Spend,
-        BigInt(0),
-        toPlutusData(currentTxIn.scriptTxIn.redeemer.data.content),
-        // TODO: handle json / raw datum
+        BigInt(index),
+        fromBuilderToPlutusData(currentTxIn.scriptTxIn.redeemer.data),
         new ExUnits(BigInt(exUnits.mem), BigInt(exUnits.steps))
       )
     );
+    redeemers.setValues(redeemersList);
+    this.txWitnessSet.setRedeemers(redeemers);
   };
   addSimpleScriptTxIn = (currentTxIn) => {
     this.addTxIn({
@@ -2195,21 +3418,12 @@ var CardanoSDKSerializer = class {
       this.scriptsProvided.add(
         Script.newNativeScript(
           NativeScript.fromCbor(
-            HexBlob6(currentTxIn.simpleScriptTxIn.scriptSource.scriptCode)
+            HexBlob8(currentTxIn.simpleScriptTxIn.scriptSource.scriptCode)
           )
-        )
+        ).toCbor()
       );
     } else if (currentTxIn.simpleScriptTxIn.scriptSource.type === "Inline") {
-      let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
-      let referenceInputsList = [...referenceInputs.values()];
-      referenceInputsList.push(
-        new TransactionInput(
-          TransactionId(currentTxIn.simpleScriptTxIn.scriptSource.txHash),
-          BigInt(currentTxIn.simpleScriptTxIn.scriptSource.txIndex)
-        )
-      );
-      referenceInputs.setValues(referenceInputsList);
-      this.txBody.setReferenceInputs(referenceInputs);
+      this.addSimpleScriptRef(currentTxIn.simpleScriptTxIn.scriptSource);
     }
   };
   addAllOutputs = (outputs) => {
@@ -2219,32 +3433,41 @@ var CardanoSDKSerializer = class {
   };
   addOutput = (output) => {
     const currentOutputs = this.txBody.outputs();
-    const cardanoOutput = new TransactionOutput(
-      Address.fromBech32(output.address),
+    currentOutputs.push(this.toCardanoOutput(output));
+    this.txBody.setOutputs(currentOutputs);
+  };
+  toCardanoOutput = (output) => {
+    let cardanoOutput = new TransactionOutput(
+      toCardanoAddress(output.address),
       toValue(output.amount)
     );
     if (output.datum?.type === "Hash") {
       cardanoOutput.setDatum(
         Datum.newDataHash(
           DatumHash.fromHexBlob(
-            HexBlob6(toPlutusData(output.datum.data.content).hash())
+            HexBlob8(fromBuilderToPlutusData(output.datum.data).hash())
           )
         )
       );
     } else if (output.datum?.type === "Inline") {
       cardanoOutput.setDatum(
-        Datum.newInlineData(
-          toPlutusData(output.datum.data.content)
-          // TODO: handle json / raw datum
-        )
+        Datum.newInlineData(fromBuilderToPlutusData(output.datum.data))
       );
+    } else if (output.datum?.type === "Embedded") {
+      const currentWitnessDatum = this.txWitnessSet.plutusData() ?? Serialization6.CborSet.fromCore([], Serialization6.PlutusData.fromCore);
+      const currentWitnessDatumValues = [...currentWitnessDatum.values()];
+      currentWitnessDatumValues.push(
+        fromBuilderToPlutusData(output.datum.data)
+      );
+      currentWitnessDatum.setValues(currentWitnessDatumValues);
+      this.txWitnessSet.setPlutusData(currentWitnessDatum);
     }
     if (output.referenceScript) {
       switch (output.referenceScript.version) {
         case "V1": {
           cardanoOutput.setScriptRef(
             Script.newPlutusV1Script(
-              PlutusV1Script.fromCbor(HexBlob6(output.referenceScript.code))
+              PlutusV1Script.fromCbor(HexBlob8(output.referenceScript.code))
             )
           );
           break;
@@ -2252,7 +3475,7 @@ var CardanoSDKSerializer = class {
         case "V2": {
           cardanoOutput.setScriptRef(
             Script.newPlutusV2Script(
-              PlutusV2Script.fromCbor(HexBlob6(output.referenceScript.code))
+              PlutusV2Script.fromCbor(HexBlob8(output.referenceScript.code))
             )
           );
           break;
@@ -2260,27 +3483,26 @@ var CardanoSDKSerializer = class {
         case "V3": {
           cardanoOutput.setScriptRef(
             Script.newPlutusV3Script(
-              PlutusV3Script.fromCbor(HexBlob6(output.referenceScript.code))
+              PlutusV3Script.fromCbor(HexBlob8(output.referenceScript.code))
             )
           );
           break;
         }
       }
     }
-    currentOutputs.push(cardanoOutput);
-    this.txBody.setOutputs(currentOutputs);
+    return cardanoOutput;
   };
   addAllReferenceInputs = (refInputs) => {
     for (let i = 0; i < refInputs.length; i++) {
-      this.addReferenceIput(refInputs[i]);
+      this.addReferenceInput(refInputs[i]);
     }
   };
-  addReferenceIput = (refInput) => {
-    let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
+  addReferenceInput = (refInput) => {
+    let referenceInputs = this.txBody.referenceInputs() ?? Serialization6.CborSet.fromCore([], TransactionInput.fromCore);
     let referenceInputsList = [...referenceInputs.values()];
     referenceInputsList.push(
       new TransactionInput(
-        TransactionId.fromHexBlob(HexBlob6(refInput.txHash)),
+        TransactionId.fromHexBlob(HexBlob8(refInput.txHash)),
         BigInt(refInput.txIndex)
       )
     );
@@ -2288,9 +3510,24 @@ var CardanoSDKSerializer = class {
     this.txBody.setReferenceInputs(referenceInputs);
   };
   addAllMints = (mints) => {
-    for (let i = 0; i < mints.length; i++) {
-      this.addMint(mints[i]);
+    for (let i2 = 0; i2 < mints.length; i2++) {
+      this.addMint(mints[i2]);
     }
+    let redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
+    let redeemersList = [...redeemers.values()];
+    let i = 0;
+    this.mintRedeemers.forEach((redeemer) => {
+      const newRedeemer = new Redeemer(
+        redeemer.tag(),
+        BigInt(i),
+        redeemer.data(),
+        redeemer.exUnits()
+      );
+      redeemersList.push(newRedeemer);
+      redeemers.setValues(redeemersList);
+      i++;
+    });
+    this.txWitnessSet.setRedeemers(redeemers);
   };
   addMint = (mint) => {
     const currentMint = this.txBody.mint() ?? /* @__PURE__ */ new Map();
@@ -2300,15 +3537,153 @@ var CardanoSDKSerializer = class {
         throw new Error("The same asset is already in the mint field");
       }
     }
-    currentMint.set(
-      AssetId.fromParts(PolicyId(mint.policyId), AssetName(mint.assetName)),
-      BigInt(mint.amount)
+    currentMint.set(
+      AssetId.fromParts(PolicyId(mint.policyId), AssetName(mint.assetName)),
+      BigInt(mint.amount)
+    );
+    this.txBody.setMint(currentMint);
+    if (mint.type === "Native") {
+      if (!mint.scriptSource)
+        throw new Error("Script source not provided for native script mint");
+      const nativeScriptSource = mint.scriptSource;
+      if (!nativeScriptSource)
+        throw new Error(
+          "A script source for a native script was not a native script somehow"
+        );
+      if (nativeScriptSource.type === "Provided") {
+        this.scriptsProvided.add(
+          Script.newNativeScript(
+            NativeScript.fromCbor(HexBlob8(nativeScriptSource.scriptCode))
+          ).toCbor()
+        );
+      } else if (nativeScriptSource.type === "Inline") {
+        this.addSimpleScriptRef(nativeScriptSource);
+      }
+    } else if (mint.type === "Plutus") {
+      if (!mint.scriptSource)
+        throw new Error("Script source not provided for plutus script mint");
+      const plutusScriptSource = mint.scriptSource;
+      if (!plutusScriptSource) {
+        throw new Error(
+          "A script source for a plutus mint was not plutus script somehow"
+        );
+      }
+      if (!mint.redeemer) {
+        throw new Error("A redeemer was not provided for a plutus mint");
+      }
+      const currentRedeemer = new Redeemer(
+        RedeemerTag.Mint,
+        BigInt(0),
+        fromBuilderToPlutusData(mint.redeemer.data),
+        new ExUnits(
+          BigInt(mint.redeemer.exUnits.mem),
+          BigInt(mint.redeemer.exUnits.steps)
+        )
+      );
+      if (this.mintRedeemers.has(mint.policyId)) {
+        if (this.mintRedeemers.get(mint.policyId)?.toCbor() !== currentRedeemer.toCbor()) {
+          throw new Error(
+            "The same minting policy must have the same redeemer"
+          );
+        }
+      } else {
+        this.mintRedeemers.set(mint.policyId, currentRedeemer);
+      }
+      if (plutusScriptSource.type === "Provided") {
+        this.addProvidedPlutusScript(plutusScriptSource.script);
+      } else if (plutusScriptSource.type === "Inline") {
+        this.addScriptRef(plutusScriptSource);
+      }
+    }
+  };
+  addAllCerts = (certs) => {
+    for (let i = 0; i < certs.length; i++) {
+      this.addCert(certs[i], i);
+    }
+  };
+  addCert = (cert, index) => {
+    const currentCerts = this.txBody.certs() ?? Serialization6.CborSet.fromCore([], Serialization6.Certificate.fromCore);
+    let currentCertsValues = [...currentCerts.values()];
+    currentCertsValues.push(toCardanoCert(cert.certType));
+    currentCerts.setValues(currentCertsValues);
+    this.txBody.setCerts(currentCerts);
+    if (cert.type === "SimpleScriptCertificate") {
+      if (!cert.simpleScriptSource)
+        throw new Error("Script source not provided for native script cert");
+      const nativeScriptSource = cert.simpleScriptSource;
+      if (!nativeScriptSource)
+        throw new Error(
+          "A script source for a native script was not a native script somehow"
+        );
+      if (nativeScriptSource.type === "Provided") {
+        this.scriptsProvided.add(
+          Script.newNativeScript(
+            NativeScript.fromCbor(HexBlob8(nativeScriptSource.scriptCode))
+          ).toCbor()
+        );
+      } else if (nativeScriptSource.type === "Inline") {
+        this.addSimpleScriptRef(nativeScriptSource);
+      }
+    } else if (cert.type === "ScriptCertificate") {
+      if (!cert.scriptSource)
+        throw new Error(
+          "Script source not provided for plutus script certificate"
+        );
+      const plutusScriptSource = cert.scriptSource;
+      if (!plutusScriptSource) {
+        throw new Error(
+          "A script source for a plutus certificate was not plutus script somehow"
+        );
+      }
+      if (!cert.redeemer) {
+        throw new Error("A redeemer was not provided for a plutus certificate");
+      }
+      let redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
+      let redeemersList = [...redeemers.values()];
+      redeemersList.push(
+        new Redeemer(
+          RedeemerTag.Cert,
+          BigInt(index),
+          fromBuilderToPlutusData(cert.redeemer.data),
+          new ExUnits(
+            BigInt(cert.redeemer.exUnits.mem),
+            BigInt(cert.redeemer.exUnits.steps)
+          )
+        )
+      );
+      redeemers.setValues(redeemersList);
+      this.txWitnessSet.setRedeemers(redeemers);
+      if (plutusScriptSource.type === "Provided") {
+        this.addProvidedPlutusScript(plutusScriptSource.script);
+      } else if (plutusScriptSource.type === "Inline") {
+        this.addScriptRef(plutusScriptSource);
+      }
+    }
+  };
+  addAllWithdrawals = (withdrawals) => {
+    for (let i = 0; i < withdrawals.length; i++) {
+      this.addWithdrawal(withdrawals[i], i);
+    }
+  };
+  addWithdrawal = (withdrawal, index) => {
+    const currentWithdrawals = this.txBody.withdrawals() ?? /* @__PURE__ */ new Map();
+    const address = toCardanoAddress(withdrawal.address);
+    const rewardAddress = address.asReward();
+    if (!rewardAddress) {
+      throw new Error("Failed to parse reward address for withdrawal");
+    }
+    currentWithdrawals.set(
+      RewardAccount.fromCredential(
+        rewardAddress.getPaymentCredential(),
+        address.getNetworkId()
+      ),
+      BigInt(withdrawal.coin)
     );
-    this.txBody.setMint(currentMint);
-    if (mint.type === "Native") {
-      if (!mint.scriptSource)
-        throw new Error("Script source not provided for native script mint");
-      const nativeScriptSource = mint.scriptSource;
+    this.txBody.setWithdrawals(currentWithdrawals);
+    if (withdrawal.type === "SimpleScriptWithdrawal") {
+      if (!withdrawal.scriptSource)
+        throw new Error("Script source not provided for native script cert");
+      const nativeScriptSource = withdrawal.scriptSource;
       if (!nativeScriptSource)
         throw new Error(
           "A script source for a native script was not a native script somehow"
@@ -2316,85 +3691,45 @@ var CardanoSDKSerializer = class {
       if (nativeScriptSource.type === "Provided") {
         this.scriptsProvided.add(
           Script.newNativeScript(
-            NativeScript.fromCbor(HexBlob6(nativeScriptSource.scriptCode))
-          )
+            NativeScript.fromCbor(HexBlob8(nativeScriptSource.scriptCode))
+          ).toCbor()
         );
       } else if (nativeScriptSource.type === "Inline") {
-        let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
-        let referenceInputsList = [...referenceInputs.values()];
-        referenceInputsList.push(
-          new TransactionInput(
-            TransactionId(nativeScriptSource.txHash),
-            BigInt(nativeScriptSource.txIndex)
-          )
-        );
-        referenceInputs.setValues(referenceInputsList);
-        this.txBody.setReferenceInputs(referenceInputs);
+        this.addSimpleScriptRef(nativeScriptSource);
       }
-    } else if (mint.type === "Plutus") {
-      if (!mint.scriptSource)
-        throw new Error("Script source not provided for plutus script mint");
-      const plutusScriptSource = mint.scriptSource;
+    } else if (withdrawal.type === "ScriptWithdrawal") {
+      if (!withdrawal.scriptSource)
+        throw new Error(
+          "Script source not provided for plutus script certificate"
+        );
+      const plutusScriptSource = withdrawal.scriptSource;
       if (!plutusScriptSource) {
         throw new Error(
-          "A script source for a plutus mint was not plutus script somehow"
+          "A script source for a plutus certificate was not plutus script somehow"
         );
       }
+      if (!withdrawal.redeemer) {
+        throw new Error("A redeemer was not provided for a plutus certificate");
+      }
+      let redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
+      let redeemersList = [...redeemers.values()];
+      redeemersList.push(
+        new Redeemer(
+          RedeemerTag.Reward,
+          BigInt(index),
+          fromBuilderToPlutusData(withdrawal.redeemer.data),
+          new ExUnits(
+            BigInt(withdrawal.redeemer.exUnits.mem),
+            BigInt(withdrawal.redeemer.exUnits.steps)
+          )
+        )
+      );
+      redeemers.setValues(redeemersList);
+      this.txWitnessSet.setRedeemers(redeemers);
       if (plutusScriptSource.type === "Provided") {
-        switch (plutusScriptSource.script.version) {
-          case "V1":
-            this.scriptsProvided.add(
-              Script.newPlutusV1Script(
-                PlutusV1Script.fromCbor(
-                  HexBlob6(plutusScriptSource.script.code)
-                )
-              )
-            );
-            break;
-          case "V2":
-            this.scriptsProvided.add(
-              Script.newPlutusV2Script(
-                PlutusV2Script.fromCbor(
-                  HexBlob6(plutusScriptSource.script.code)
-                )
-              )
-            );
-            break;
-          case "V3":
-            this.scriptsProvided.add(
-              Script.newPlutusV3Script(
-                PlutusV3Script.fromCbor(
-                  HexBlob6(plutusScriptSource.script.code)
-                )
-              )
-            );
-            break;
-        }
+        this.addProvidedPlutusScript(plutusScriptSource.script);
       } else if (plutusScriptSource.type === "Inline") {
-        let referenceInputs = this.txBody.referenceInputs() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
-        let referenceInputsList = [...referenceInputs.values()];
-        referenceInputsList.push(
-          new TransactionInput(
-            TransactionId(plutusScriptSource.txHash),
-            BigInt(plutusScriptSource.txIndex)
-          )
-        );
-        referenceInputs.setValues(referenceInputsList);
-        this.txBody.setReferenceInputs(referenceInputs);
-        switch (plutusScriptSource.version) {
-          case "V1": {
-            this.usedLanguages[PlutusLanguageVersion.V1] = true;
-            break;
-          }
-          case "V2": {
-            this.usedLanguages[PlutusLanguageVersion.V2] = true;
-            break;
-          }
-          case "V3": {
-            this.usedLanguages[PlutusLanguageVersion.V3] = true;
-            break;
-          }
-        }
+        this.addScriptRef(plutusScriptSource);
       }
     }
   };
@@ -2410,7 +3745,7 @@ var CardanoSDKSerializer = class {
       TransactionId(collateral.txIn.txHash),
       BigInt(collateral.txIn.txIndex)
     );
-    const collateralInputs = this.txBody.collateral() ?? Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
+    const collateralInputs = this.txBody.collateral() ?? Serialization6.CborSet.fromCore([], TransactionInput.fromCore);
     const collateralInputsList = [
       ...collateralInputs.values()
     ];
@@ -2422,7 +3757,7 @@ var CardanoSDKSerializer = class {
     collateralInputsList.push(cardanoTxIn);
     collateralInputs.setValues(collateralInputsList);
     const cardanoTxOut = new TransactionOutput(
-      Address.fromBech32(collateral.txIn.address),
+      toCardanoAddress(collateral.txIn.address),
       toValue(collateral.txIn.amount)
     );
     this.utxoContext.set(cardanoTxIn, cardanoTxOut);
@@ -2436,29 +3771,31 @@ var CardanoSDKSerializer = class {
       this.txBody.setTtl(Slot(validity.invalidHereafter));
     }
   };
-  buildWitnessSet = () => {
-    const inputs = this.txBody.inputs();
-    for (let i = 0; i < inputs.size(); i += 1) {
-      const input = inputs.values().at(i);
-      if (input) {
-        let redeemer = this.redeemerContext.get(input);
-        if (redeemer) {
-          redeemer.setIndex(BigInt(i));
-        }
-      }
+  addAllRequiredSignatures = (requiredSignatures) => {
+    const requiredSigners = this.txBody.requiredSigners() ?? Serialization6.CborSet.fromCore([], Serialization6.Hash.fromCore);
+    let requiredSignerValues = [...requiredSigners.values()];
+    for (const requiredSigner of requiredSignatures) {
+      requiredSignerValues.push(
+        Serialization6.Hash.fromCore(Ed25519KeyHashHex2(requiredSigner))
+      );
     }
-    let redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
-    let redeemersList = [...redeemers.values()];
-    this.redeemerContext.forEach((redeemer) => {
-      redeemersList.push(redeemer);
-    });
-    redeemers.setValues(redeemersList);
-    this.txWitnessSet.setRedeemers(redeemers);
-    let nativeScripts = this.txWitnessSet.nativeScripts() ?? Serialization4.CborSet.fromCore([], NativeScript.fromCore);
-    let v1Scripts = this.txWitnessSet.plutusV1Scripts() ?? Serialization4.CborSet.fromCore([], PlutusV1Script.fromCore);
-    let v2Scripts = this.txWitnessSet.plutusV2Scripts() ?? Serialization4.CborSet.fromCore([], PlutusV2Script.fromCore);
-    let v3Scripts = this.txWitnessSet.plutusV3Scripts() ?? Serialization4.CborSet.fromCore([], PlutusV3Script.fromCore);
-    this.scriptsProvided.forEach((script) => {
+    requiredSigners.setValues(requiredSignerValues);
+    this.txBody.setRequiredSigners(requiredSigners);
+  };
+  addMetadata = (metadata) => {
+    this.txAuxilliaryData.setMetadata(
+      new Serialization6.GeneralTransactionMetadata(
+        toCardanoMetadataMap(metadata)
+      )
+    );
+  };
+  buildWitnessSet = () => {
+    let nativeScripts = this.txWitnessSet.nativeScripts() ?? Serialization6.CborSet.fromCore([], NativeScript.fromCore);
+    let v1Scripts = this.txWitnessSet.plutusV1Scripts() ?? Serialization6.CborSet.fromCore([], PlutusV1Script.fromCore);
+    let v2Scripts = this.txWitnessSet.plutusV2Scripts() ?? Serialization6.CborSet.fromCore([], PlutusV2Script.fromCore);
+    let v3Scripts = this.txWitnessSet.plutusV3Scripts() ?? Serialization6.CborSet.fromCore([], PlutusV3Script.fromCore);
+    this.scriptsProvided.forEach((scriptHex) => {
+      const script = Script.fromCbor(HexBlob8(scriptHex));
       if (script.asNative() !== void 0) {
         let nativeScriptsList = [...nativeScripts.values()];
         nativeScriptsList.push(script.asNative());
@@ -2481,20 +3818,23 @@ var CardanoSDKSerializer = class {
       this.txWitnessSet.setPlutusV2Scripts(v2Scripts);
       this.txWitnessSet.setPlutusV3Scripts(v3Scripts);
     });
-    let datums = this.txWitnessSet.plutusData() ?? Serialization4.CborSet.fromCore([], PlutusData.fromCore);
+    let datums = this.txWitnessSet.plutusData() ?? Serialization6.CborSet.fromCore([], PlutusData.fromCore);
+    let datumsList = [...datums.values()];
     this.datumsProvided.forEach((datum) => {
-      let datumsList = [...datums.values()];
       datumsList.push(datum);
-      datums.setValues(datumsList);
     });
+    datums.setValues(datumsList);
     this.txWitnessSet.setPlutusData(datums);
-    let costModelV1 = Serialization4.CostModel.newPlutusV1(
+    let costModelV1 = Serialization6.CostModel.newPlutusV1(
       DEFAULT_V1_COST_MODEL_LIST
     );
-    let costModelV2 = Serialization4.CostModel.newPlutusV2(
+    let costModelV2 = Serialization6.CostModel.newPlutusV2(
       DEFAULT_V2_COST_MODEL_LIST
     );
-    let costModels = new Serialization4.Costmdls();
+    let costModelV3 = Serialization6.CostModel.newPlutusV3(
+      DEFAULT_V3_COST_MODEL_LIST
+    );
+    let costModels = new Serialization6.Costmdls();
     if (this.usedLanguages[PlutusLanguageVersion.V1]) {
       costModels.insert(costModelV1);
     }
@@ -2502,7 +3842,9 @@ var CardanoSDKSerializer = class {
       costModels.insert(costModelV2);
     }
     if (this.usedLanguages[PlutusLanguageVersion.V3]) {
+      costModels.insert(costModelV3);
     }
+    const redeemers = this.txWitnessSet.redeemers() ?? Redeemers.fromCore([]);
     let scriptDataHash = hashScriptData(
       costModels,
       redeemers.size() > 0 ? [...redeemers.values()] : void 0,
@@ -2511,8 +3853,38 @@ var CardanoSDKSerializer = class {
     if (scriptDataHash) {
       this.txBody.setScriptDataHash(scriptDataHash);
     }
+    let auxiliaryDataHash = computeAuxiliaryDataHash(
+      this.txAuxilliaryData.toCore()
+    );
+    if (auxiliaryDataHash) {
+      this.txBody.setAuxiliaryDataHash(auxiliaryDataHash);
+    }
+  };
+  removeInputRefInputOverlap = () => {
+    let refInputsValues = [];
+    const inputs = this.txBody.inputs()?.values();
+    if (this.txBody.referenceInputs()) {
+      const currentRefInputValues = this.txBody.referenceInputs().values();
+      currentRefInputValues.forEach((refInput) => {
+        let found = false;
+        for (let i = 0; i < inputs.length; i++) {
+          if (refInput.toCbor() === inputs[i].toCbor()) {
+            found = true;
+          }
+        }
+        if (!found) {
+          refInputsValues.push(refInput);
+        }
+      });
+      this.txBody.setReferenceInputs(
+        Serialization6.CborSet.fromCore(
+          refInputsValues.map((input) => input.toCore()),
+          TransactionInput.fromCore
+        )
+      );
+    }
   };
-  balanceTx = (changeAddress, numberOfRequiredWitnesses, protocolParams) => {
+  balanceTx = (changeAddress) => {
     if (changeAddress === "") {
       throw new Error("Can't balance tx without a change address");
     }
@@ -2546,47 +3918,421 @@ var CardanoSDKSerializer = class {
         remainingValue = subValue(remainingValue, output.amount());
       }
     }
+    const certs = this.txBody.certs();
+    if (certs) {
+      certs.values().forEach((cert) => {
+        switch (cert.toCore().__typename) {
+          case CertificateType.StakeRegistration: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(BigInt(this.protocolParams.keyDeposit))
+            );
+            break;
+          }
+          case CertificateType.StakeDeregistration: {
+            remainingValue = mergeValue(
+              remainingValue,
+              new Value(BigInt(this.protocolParams.keyDeposit))
+            );
+            break;
+          }
+          case CertificateType.Registration: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(BigInt(cert.asRegistrationCert()?.deposit() ?? 0))
+            );
+            break;
+          }
+          case CertificateType.Unregistration: {
+            remainingValue = mergeValue(
+              remainingValue,
+              new Value(BigInt(cert.asUnregistrationCert()?.deposit() ?? 0))
+            );
+            break;
+          }
+          case CertificateType.PoolRegistration: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(BigInt(this.protocolParams.poolDeposit))
+            );
+            break;
+          }
+          case CertificateType.PoolRetirement: {
+            remainingValue = mergeValue(
+              remainingValue,
+              new Value(BigInt(this.protocolParams.poolDeposit))
+            );
+            break;
+          }
+          case CertificateType.RegisterDelegateRepresentative: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(
+                BigInt(
+                  cert.asRegisterDelegateRepresentativeCert()?.deposit() ?? 0
+                )
+              )
+            );
+            break;
+          }
+          case CertificateType.UnregisterDelegateRepresentative: {
+            remainingValue = mergeValue(
+              remainingValue,
+              new Value(
+                BigInt(
+                  cert.asUnregisterDelegateRepresentativeCert()?.deposit() ?? 0
+                )
+              )
+            );
+            break;
+          }
+          case CertificateType.StakeRegistrationDelegation: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(
+                BigInt(
+                  cert.asStakeRegistrationDelegationCert()?.deposit() ?? 0
+                )
+              )
+            );
+            break;
+          }
+          case CertificateType.StakeVoteRegistrationDelegation: {
+            remainingValue = subValue(
+              remainingValue,
+              new Value(
+                BigInt(
+                  cert.asStakeVoteRegistrationDelegationCert()?.deposit() ?? 0
+                )
+              )
+            );
+            break;
+          }
+        }
+      });
+    }
     if (remainingValue.coin() < 0 || !empty(negatives(remainingValue))) {
       throw new Error(`Not enough funds to satisfy outputs`);
     }
     currentOutputs.push(
-      new TransactionOutput(Address.fromBech32(changeAddress), remainingValue)
+      new TransactionOutput(toCardanoAddress(changeAddress), remainingValue)
     );
     this.txBody.setOutputs(currentOutputs);
     this.txBody.setFee(BigInt("10000000"));
+    const numberOfRequiredWitnesses = this.countNumberOfRequiredWitnesses();
     const dummyTx = this.createDummyTx(numberOfRequiredWitnesses);
-    const fee = protocolParams.minFeeB + dummyTx.toCbor().length / 2 * Number(protocolParams.coinsPerUtxoSize);
-    this.txBody.setFee(BigInt(fee));
+    const fee = calculateFees(
+      this.protocolParams.minFeeA,
+      this.protocolParams.minFeeB,
+      this.protocolParams.minFeeRefScriptCostPerByte,
+      this.protocolParams.priceMem,
+      this.protocolParams.priceStep,
+      dummyTx,
+      this.refScriptSize
+    );
+    this.txBody.setFee(fee);
     const changeOutput = currentOutputs.pop();
     if (!changeOutput) {
       throw new Error(
         "Somehow the output length was 0 after attempting to calculate fees"
       );
     }
-    changeOutput.amount().setCoin(changeOutput.amount().coin() - BigInt(fee));
-    currentOutputs.push(changeOutput);
+    if (changeOutput.amount().coin() - fee > 0) {
+      changeOutput.amount().setCoin(changeOutput.amount().coin() - fee);
+      currentOutputs.push(changeOutput);
+    } else if (changeOutput.amount().coin() - fee < 0) {
+      throw new Error(
+        "There was enough inputs to cover outputs, but not enough to cover fees"
+      );
+    }
     this.txBody.setOutputs(currentOutputs);
   };
   createDummyTx = (numberOfRequiredWitnesses) => {
-    let dummyWitnessSet = new TransactionWitnessSet();
+    let dummyWitnessSet = TransactionWitnessSet.fromCbor(
+      HexBlob8(this.txWitnessSet.toCbor())
+    );
     const dummyVkeyWitnesses = [];
     for (let i = 0; i < numberOfRequiredWitnesses; i++) {
       dummyVkeyWitnesses.push([
-        Ed25519PublicKeyHex2("0".repeat(64)),
-        Ed25519SignatureHex2("0".repeat(128))
+        Ed25519PublicKeyHex2(String(i).repeat(64)),
+        Ed25519SignatureHex2(String(i).repeat(128))
       ]);
     }
     dummyWitnessSet.setVkeys(
-      Serialization4.CborSet.fromCore(dummyVkeyWitnesses, VkeyWitness.fromCore)
+      Serialization6.CborSet.fromCore(dummyVkeyWitnesses, VkeyWitness.fromCore)
+    );
+    return new Transaction(this.txBody, dummyWitnessSet, this.txAuxilliaryData);
+  };
+  addScriptRef = (scriptSource) => {
+    if (scriptSource.type !== "Inline") {
+      return;
+    }
+    let referenceInputs = this.txBody.referenceInputs() ?? Serialization6.CborSet.fromCore([], TransactionInput.fromCore);
+    let referenceInputsList = [...referenceInputs.values()];
+    referenceInputsList.push(
+      new TransactionInput(
+        TransactionId(scriptSource.txHash),
+        BigInt(scriptSource.txIndex)
+      )
+    );
+    referenceInputs.setValues(referenceInputsList);
+    this.txBody.setReferenceInputs(referenceInputs);
+    switch (scriptSource.version) {
+      case "V1": {
+        this.usedLanguages[PlutusLanguageVersion.V1] = true;
+        break;
+      }
+      case "V2": {
+        this.usedLanguages[PlutusLanguageVersion.V2] = true;
+        break;
+      }
+      case "V3": {
+        this.usedLanguages[PlutusLanguageVersion.V3] = true;
+        break;
+      }
+    }
+    if (scriptSource.scriptSize) {
+      this.refScriptSize += Number(scriptSource.scriptSize);
+    } else {
+      throw new Error(
+        "A reference script was used without providing its size, this must be provided as fee calculations are based on it"
+      );
+    }
+  };
+  addSimpleScriptRef = (simpleScriptSource) => {
+    if (simpleScriptSource.type !== "Inline") {
+      return;
+    }
+    let referenceInputs = this.txBody.referenceInputs() ?? Serialization6.CborSet.fromCore([], TransactionInput.fromCore);
+    let referenceInputsList = [...referenceInputs.values()];
+    referenceInputsList.push(
+      new TransactionInput(
+        TransactionId(simpleScriptSource.txHash),
+        BigInt(simpleScriptSource.txIndex)
+      )
     );
-    return new Transaction(this.txBody, dummyWitnessSet);
+    if (simpleScriptSource.scriptSize) {
+      this.refScriptSize += Number(simpleScriptSource.scriptSize);
+    } else {
+      throw new Error(
+        "A reference script was used without providing its size, this must be provided as fee calculations are based on it"
+      );
+    }
+    referenceInputs.setValues(referenceInputsList);
+    this.txBody.setReferenceInputs(referenceInputs);
+  };
+  countNumberOfRequiredWitnesses() {
+    let requiredWitnesses = /* @__PURE__ */ new Set();
+    const inputs = this.txBody.inputs().values();
+    for (let i = 0; i < inputs.length; i++) {
+      const input = inputs[i];
+      const addressPaymentPart = this.utxoContext.get(input)?.address().getProps().paymentPart;
+      if (addressPaymentPart?.type === 0) {
+        requiredWitnesses.add(addressPaymentPart.hash);
+      }
+    }
+    const collateralInputs = this.txBody.collateral()?.values();
+    if (collateralInputs) {
+      for (let i = 0; i < collateralInputs?.length; i++) {
+        const collateralInput = collateralInputs[i];
+        const addressPaymentPart = this.utxoContext.get(collateralInput)?.address().getProps().paymentPart;
+        if (addressPaymentPart?.type === 0) {
+          requiredWitnesses.add(addressPaymentPart.hash);
+        }
+      }
+    }
+    const withdrawalKeys = this.txBody.withdrawals()?.keys();
+    if (withdrawalKeys) {
+      for (let withdrawalKey of withdrawalKeys) {
+        requiredWitnesses.add(RewardAccount.toHash(withdrawalKey));
+      }
+    }
+    const certs = this.txBody.certs()?.values();
+    if (certs) {
+      for (let cert of certs) {
+        const coreCert = cert.toCore();
+        switch (coreCert.__typename) {
+          case CertificateType.StakeRegistration: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.StakeDeregistration: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.PoolRegistration: {
+            for (let owner of coreCert.poolParameters.owners) {
+              requiredWitnesses.add(RewardAccount.toHash(owner));
+            }
+            requiredWitnesses.add(PoolId.toKeyHash(coreCert.poolParameters.id));
+            break;
+          }
+          case CertificateType.PoolRetirement: {
+            requiredWitnesses.add(PoolId.toKeyHash(coreCert.poolId));
+            break;
+          }
+          case CertificateType.StakeDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.MIR:
+            break;
+          case CertificateType.GenesisKeyDelegation: {
+            requiredWitnesses.add(coreCert.genesisDelegateHash);
+            break;
+          }
+          case CertificateType.Registration: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.Unregistration: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.VoteDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.StakeVoteDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.StakeRegistrationDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.VoteRegistrationDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.StakeVoteRegistrationDelegation: {
+            requiredWitnesses.add(coreCert.stakeCredential.hash);
+            break;
+          }
+          case CertificateType.AuthorizeCommitteeHot: {
+            requiredWitnesses.add(coreCert.hotCredential.hash);
+            break;
+          }
+          case CertificateType.ResignCommitteeCold: {
+            requiredWitnesses.add(coreCert.coldCredential.hash);
+            break;
+          }
+          case CertificateType.RegisterDelegateRepresentative: {
+            requiredWitnesses.add(coreCert.dRepCredential.hash);
+            break;
+          }
+          case CertificateType.UnregisterDelegateRepresentative: {
+            requiredWitnesses.add(coreCert.dRepCredential.hash);
+            break;
+          }
+          case CertificateType.UpdateDelegateRepresentative: {
+            requiredWitnesses.add(coreCert.dRepCredential.hash);
+            break;
+          }
+        }
+      }
+    }
+    for (const scriptHex of this.scriptsProvided) {
+      const script = Script.fromCbor(HexBlob8(scriptHex));
+      let nativeScript = script.asNative();
+      if (nativeScript) {
+        this.addKeyHashesFromNativeScript(nativeScript, requiredWitnesses);
+      }
+    }
+    const requiredSigners = this.txBody.requiredSigners()?.values();
+    if (requiredSigners) {
+      for (let i = 0; i < requiredSigners.length; i++) {
+        requiredWitnesses.add(requiredSigners[i].toCbor());
+      }
+    }
+    return requiredWitnesses.size;
+  }
+  addKeyHashesFromNativeScript(script, keyHashes) {
+    const scriptCore = script.toCore();
+    switch (scriptCore.kind) {
+      case RequireSignature: {
+        keyHashes.add(scriptCore.keyHash);
+        break;
+      }
+      case RequireTimeAfter: {
+        break;
+      }
+      case RequireTimeBefore: {
+        break;
+      }
+      case RequireAllOf: {
+        for (const innerScript of scriptCore.scripts) {
+          this.addKeyHashesFromNativeScript(
+            NativeScript.fromCore(innerScript),
+            keyHashes
+          );
+        }
+        break;
+      }
+      case RequireAnyOf: {
+        for (const innerScript of scriptCore.scripts) {
+          this.addKeyHashesFromNativeScript(
+            NativeScript.fromCore(innerScript),
+            keyHashes
+          );
+        }
+        break;
+      }
+      case RequireNOf: {
+        for (const innerScript of scriptCore.scripts) {
+          this.addKeyHashesFromNativeScript(
+            NativeScript.fromCore(innerScript),
+            keyHashes
+          );
+        }
+        break;
+      }
+    }
+    return keyHashes;
+  }
+  addProvidedPlutusScript = (script) => {
+    switch (script.version) {
+      case "V1": {
+        this.scriptsProvided.add(
+          Script.newPlutusV1Script(
+            PlutusV1Script.fromCbor(HexBlob8(script.code))
+          ).toCbor()
+        );
+        this.usedLanguages[PlutusLanguageVersion.V1] = true;
+        break;
+      }
+      case "V2": {
+        this.scriptsProvided.add(
+          Script.newPlutusV2Script(
+            PlutusV2Script.fromCbor(HexBlob8(script.code))
+          ).toCbor()
+        );
+        this.usedLanguages[PlutusLanguageVersion.V2] = true;
+        break;
+      }
+      case "V3": {
+        this.scriptsProvided.add(
+          Script.newPlutusV3Script(
+            PlutusV3Script.fromCbor(HexBlob8(script.code))
+          ).toCbor()
+        );
+        this.usedLanguages[PlutusLanguageVersion.V3] = true;
+        break;
+      }
+    }
   };
 };
 
 // src/plutus-tools/index.ts
+import { Cbor as Cbor2, CborBytes as CborBytes2 } from "@harmoniclabs/cbor";
 import { dataFromCbor } from "@harmoniclabs/plutus-data";
-import { parseUPLC, Application, UPLCProgram, UPLCConst, encodeUPLC } from "@harmoniclabs/uplc";
-import { Cbor, CborBytes } from "@harmoniclabs/cbor";
+import {
+  Application,
+  encodeUPLC,
+  parseUPLC,
+  UPLCConst,
+  UPLCProgram
+} from "@harmoniclabs/uplc";
 var supportedPlutusCoreVersions = [
   {
     version: [1, 0, 0],
@@ -2597,6 +4343,19 @@ var supportedPlutusCoreVersions = [
     language: "Plutus V3"
   }
 ];
+var applyArgsToPlutusScript = (args, program, outputEncoding) => {
+  const purePlutusBytes = getPurePlutusBytes(program);
+  const parsedProgram = parseUPLC(purePlutusBytes, "flat");
+  const decodedArgs = args.map((arg) => dataFromCbor(arg));
+  let body = parsedProgram.body;
+  for (const plutusData of decodedArgs) {
+    const argTerm = UPLCConst.data(plutusData);
+    body = new Application(body, argTerm);
+  }
+  const encodedProgram = new UPLCProgram(parsedProgram.version, body);
+  const newPlutusScriptBytes = encodeUPLC(encodedProgram).toBuffer().buffer;
+  return applyEncoding(newPlutusScriptBytes, outputEncoding);
+};
 var normalizePlutusScript = (plutusScript, encoding) => {
   const bytes = Buffer.from(plutusScript, "hex");
   const purePlutusBytes = getPurePlutusBytes(bytes);
@@ -2621,8 +4380,8 @@ var getPurePlutusBytes = (plutusScript) => {
       if (hasSupportedPlutusVersion(unwrappedScript)) {
         return unwrappedScript;
       }
-      const cbor = Cbor.parse(unwrappedScript);
-      if (cbor instanceof CborBytes) {
+      const cbor = Cbor2.parse(unwrappedScript);
+      if (cbor instanceof CborBytes2) {
         unwrappedScript = cbor.bytes;
       } else {
         break;
@@ -2637,7 +4396,7 @@ var getPurePlutusBytes = (plutusScript) => {
   throw new Error("Unsupported Plutus version or invalid Plutus script bytes");
 };
 var applyCborEncoding = (plutusScript) => {
-  return Cbor.encode(new CborBytes(plutusScript)).toBuffer();
+  return Cbor2.encode(new CborBytes2(plutusScript)).toBuffer();
 };
 var applyEncoding = (plutusScript, outputEncoding) => {
   switch (outputEncoding) {
@@ -2651,10 +4410,56 @@ var applyEncoding = (plutusScript, outputEncoding) => {
       return applyCborEncoding(plutusScript);
   }
 };
+var applyParamsToScript = (rawScript, params, type = "Mesh") => {
+  let plutusParams = [];
+  switch (type) {
+    case "JSON":
+      params.forEach((param) => {
+        plutusParams.push(
+          fromBuilderToPlutusData({
+            type: "JSON",
+            content: param
+          })
+        );
+      });
+      break;
+    case "CBOR":
+      params.forEach((param) => {
+        plutusParams.push(
+          fromBuilderToPlutusData({
+            type: "CBOR",
+            content: param
+          })
+        );
+      });
+      break;
+    case "Mesh":
+      params.forEach((param) => {
+        plutusParams.push(
+          fromBuilderToPlutusData({
+            type: "Mesh",
+            content: param
+          })
+        );
+      });
+      break;
+  }
+  const byteParams = plutusParams.map((param) => {
+    return Buffer.from(param.toCbor(), "hex");
+  });
+  const scriptHex = Buffer.from(
+    applyArgsToPlutusScript(
+      byteParams,
+      Buffer.from(rawScript, "hex"),
+      "DoubleCBOR"
+    )
+  ).toString("hex");
+  return scriptHex;
+};
 
 // src/index.ts
 import * as CardanoSDKUtil from "@cardano-sdk/util";
-import * as Crypto3 from "@cardano-sdk/crypto";
+import * as Crypto2 from "@cardano-sdk/crypto";
 import * as CardanoSDK from "@cardano-sdk/core";
 export {
   Address,
@@ -2662,15 +4467,17 @@ export {
   AssetFingerprint,
   AssetId,
   AssetName,
+  AuxilliaryData,
   BaseAddress,
   Bip32PrivateKey2 as Bip32PrivateKey,
   Bip32PrivateKeyHex2 as Bip32PrivateKeyHex,
-  Cardano4 as Cardano,
+  Cardano5 as Cardano,
   CardanoSDK,
   CardanoSDKSerializer,
   CardanoSDKUtil,
   CborSet,
   CborWriter,
+  CertIndex,
   Certificate,
   CertificateType,
   ConstrPlutusData,
@@ -2679,7 +4486,7 @@ export {
   Costmdls,
   Credential,
   CredentialType,
-  Crypto3 as Crypto,
+  Crypto2 as Crypto,
   DRep,
   DRepID,
   Datum,
@@ -2698,16 +4505,20 @@ export {
   Hash,
   Hash28ByteBase162 as Hash28ByteBase16,
   Hash32ByteBase162 as Hash32ByteBase16,
+  MetadatumList,
+  MetadatumMap,
   NativeScript,
   NetworkId,
   PaymentAddress,
   PlutusData,
+  PlutusDataKind,
   PlutusLanguageVersion,
   PlutusList,
   PlutusMap,
   PlutusV1Script,
   PlutusV2Script,
   PlutusV3Script,
+  PointerAddress,
   PolicyId,
   PoolId,
   Redeemer,
@@ -2725,7 +4536,7 @@ export {
   Script,
   ScriptHash,
   ScriptPubkey,
-  Serialization5 as Serialization,
+  Serialization7 as Serialization,
   Slot,
   StakeCredentialStatus,
   StakeDelegation,
@@ -2744,14 +4555,21 @@ export {
   TransactionBody,
   TransactionId,
   TransactionInput,
+  TransactionMetadatum,
   TransactionOutput,
   TransactionUnspentOutput,
   TransactionWitnessSet,
+  TxIndex,
   Value,
   VkeyWitness,
   VrfVkBech32,
+  addrBech32ToPlutusDataHex,
+  addrBech32ToPlutusDataObj,
   addressToBech32,
+  applyEncoding,
+  applyParamsToScript,
   assetTypes,
+  blake2b2 as blake2b,
   buildBaseAddress,
   buildBip32PrivateKey,
   buildDRepID,
@@ -2759,8 +4577,11 @@ export {
   buildKeys,
   buildRewardAddress,
   buildScriptPubkey,
+  bytesToHex,
   checkSignature,
+  computeAuxiliaryDataHash,
   deserializeAddress,
+  deserializeBech32Address,
   deserializeDataHash,
   deserializeEd25519KeyHash,
   deserializeNativeScript,
@@ -2773,18 +4594,28 @@ export {
   deserializeTxUnspentOutput,
   deserializeValue,
   empty,
+  fromBuilderToPlutusData,
+  fromJsonToPlutusData,
   fromNativeScript,
+  fromPlutusDataToJson,
   fromScriptRef,
   fromTxUnspentOutput,
   fromValue,
   generateNonce,
   getCoseKeyFromPublicKey,
+  getDRepIds,
   getPublicKeyFromCoseKey,
+  hexToBech32,
+  hexToBytes,
+  keyHashToRewardAddress,
   mergeValue,
   negateValue,
   negatives,
   normalizePlutusScript,
+  parseDatumCbor,
+  parseInlineDatum,
   resolveDataHash,
+  resolveEd25519KeyHash,
   resolveNativeScriptAddress,
   resolveNativeScriptHash,
   resolvePaymentKeyHash,
@@ -2793,18 +4624,29 @@ export {
   resolvePoolId,
   resolvePrivateKey,
   resolveRewardAddress,
+  resolveScriptHashDRepId,
   resolveScriptRef,
   resolveStakeKeyHash,
   resolveTxHash,
+  scriptHashToBech32,
+  scriptHashToRewardAddress,
+  serializeAddressObj,
+  serializePlutusAddressToBech32,
+  serialzeAddress,
   signData,
   subValue,
   toAddress,
   toBaseAddress,
+  toCardanoAddress,
+  toDRep,
   toEnterpriseAddress,
   toNativeScript,
   toPlutusData,
   toRewardAddress,
   toScriptRef,
   toTxUnspentOutput,
-  toValue
+  toValue,
+  utf8ToBytes,
+  utf8ToHex,
+  v2ScriptToBech32
 };