@meshsdk/core-cst 1.5.28

package/dist/index.mjs

@@ -0,0 +1,1324 @@
+// src/index.ts
+import { Cardano as Cardano4, Serialization as Serialization5 } from "@cardano-sdk/core";
+
+// src/stricahq/index.ts
+import {
+  Bip32PrivateKey,
+  Bip32PublicKey,
+  PublicKey,
+  PrivateKey as StricahqPrivateKey
+} from "@stricahq/bip32ed25519";
+import hash from "hash.js";
+var PrivateKey = class extends StricahqPrivateKey {
+  constructor(privKey, extended = true) {
+    if (!extended) {
+      let extendedSecret = hash.sha512().update(privKey).digest();
+      if (extendedSecret[0] && extendedSecret[31]) {
+        extendedSecret[0] &= 248;
+        extendedSecret[31] &= 63;
+        extendedSecret[31] |= 64;
+      }
+      privKey = Buffer.from(extendedSecret);
+    }
+    super(privKey);
+  }
+};
+
+// src/types/cardano-sdk.ts
+import { Cardano, Serialization } from "@cardano-sdk/core";
+import * as Crypto from "@cardano-sdk/crypto";
+import { typedHex } from "@cardano-sdk/util";
+var Slot = Cardano.Slot;
+var Value = Serialization.Value;
+var Transaction = Serialization.Transaction;
+var TransactionId = Cardano.TransactionId;
+var TransactionBody = Serialization.TransactionBody;
+var TransactionWitnessSet = Serialization.TransactionWitnessSet;
+var TransactionUnspentOutput = Serialization.TransactionUnspentOutput;
+var TransactionInput = Serialization.TransactionInput;
+var TransactionOutput = Serialization.TransactionOutput;
+var PlutusData = Serialization.PlutusData;
+var PlutusList = Serialization.PlutusList;
+var PlutusMap = Serialization.PlutusMap;
+var Redeemers = Serialization.Redeemers;
+var Redeemer = Serialization.Redeemer;
+var RedeemerPurpose = Cardano.RedeemerPurpose;
+var RedeemerTag = Serialization.RedeemerTag;
+var Script = Serialization.Script;
+var PolicyId = Cardano.PolicyId;
+var AssetName = Cardano.AssetName;
+var AssetId = Cardano.AssetId;
+var ScriptHash = Crypto.Hash28ByteBase16;
+var Address = Cardano.Address;
+var RewardAddress = Cardano.RewardAddress;
+var AddressType = Cardano.AddressType;
+var BaseAddress = Cardano.BaseAddress;
+var EnterpriseAddress = Cardano.EnterpriseAddress;
+var PaymentAddress = Cardano.PaymentAddress;
+var AssetFingerprint = Cardano.AssetFingerprint;
+var Credential = Serialization.Credential;
+var Ed25519PublicKeyHex2 = Crypto.Ed25519PublicKeyHex;
+var Ed25519PrivateNormalKeyHex = (value) => typedHex(value, 64);
+var Ed25519PrivateExtendedKeyHex = (value) => typedHex(value, 128);
+var Ed25519KeyHash2 = Crypto.Ed25519KeyHash;
+var Ed25519KeyHashHex2 = Crypto.Ed25519KeyHashHex;
+var Hash28ByteBase162 = Crypto.Hash28ByteBase16;
+var Hash32ByteBase162 = Crypto.Hash32ByteBase16;
+var CredentialType = Cardano.CredentialType;
+var Certificate = Serialization.Certificate;
+var PoolId = Cardano.PoolId;
+var StakeRegistration = Serialization.StakeRegistration;
+var StakeDelegation = Serialization.StakeDelegation;
+var CertificateType = Cardano.CertificateType;
+var VkeyWitness = Serialization.VkeyWitness;
+var Ed25519SignatureHex2 = Crypto.Ed25519SignatureHex;
+var Ed25519PublicKey2 = Crypto.Ed25519PublicKey;
+var Ed25519Signature2 = Crypto.Ed25519Signature;
+var Bip32PrivateKey3 = Crypto.Bip32PrivateKey;
+var Bip32PrivateKeyHex2 = Crypto.Bip32PrivateKeyHex;
+var PlutusLanguageVersion = Cardano.PlutusLanguageVersion;
+var NativeScript = Serialization.NativeScript;
+var PlutusV1Script = Serialization.PlutusV1Script;
+var PlutusV2Script = Serialization.PlutusV2Script;
+var PlutusV3Script = Serialization.PlutusV3Script;
+var Costmdls = Serialization.Costmdls;
+var CostModel = Serialization.CostModel;
+var CborWriter = Serialization.CborWriter;
+var ConstrPlutusData = Serialization.ConstrPlutusData;
+var RewardAccount = Cardano.RewardAccount;
+var Hash = Serialization.Hash;
+var DatumHash = Crypto.Hash32ByteBase16;
+var Datum = Serialization.Datum;
+var ExUnits = Serialization.ExUnits;
+var NetworkId = Cardano.NetworkId;
+var DatumKind = Serialization.DatumKind;
+var CborSet = Serialization.CborSet;
+var RequireAllOf = Cardano.NativeScriptKind.RequireAllOf;
+var RequireAnyOf = Cardano.NativeScriptKind.RequireAnyOf;
+var RequireNOf = Cardano.NativeScriptKind.RequireNOf;
+var RequireSignature = Cardano.NativeScriptKind.RequireSignature;
+var RequireTimeAfter = Cardano.NativeScriptKind.RequireTimeAfter;
+var RequireTimeBefore = Cardano.NativeScriptKind.RequireTimeBefore;
+var VrfVkBech32 = Cardano.VrfVkBech32;
+var ScriptPubkey = Serialization.ScriptPubkey;
+
+// src/cip8/index.ts
+var signData = (data, privateKey) => {
+  const payload = Buffer.from(data);
+  const signature = privateKey.sign(payload);
+  return {
+    key: privateKey.toPublicKey().toBytes().toString("hex"),
+    signature: signature.toString("hex")
+  };
+};
+var checkSignature = (data, { key, signature }) => {
+  const publicKey = new PublicKey(Buffer.from(key, "hex"));
+  return publicKey.verify(Buffer.from(signature, "hex"), Buffer.from(data));
+};
+
+// src/resolvers/index.ts
+import { Cardano as Cardano2 } from "@cardano-sdk/core";
+import { blake2b } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob3 } from "@cardano-sdk/util";
+
+// src/utils/builder.ts
+import { pbkdf2Sync } from "pbkdf2";
+import { HARDENED_KEY_START } from "@meshsdk/common";
+var buildBaseAddress = (networkId, paymentKeyHash, stakeKeyHash) => {
+  return BaseAddress.fromCredentials(
+    networkId,
+    {
+      hash: paymentKeyHash,
+      type: CredentialType.KeyHash
+    },
+    {
+      hash: stakeKeyHash,
+      type: CredentialType.KeyHash
+    }
+  );
+};
+var buildEnterpriseAddress = (networkId, paymentKeyHash) => {
+  return EnterpriseAddress.fromCredentials(networkId, {
+    hash: paymentKeyHash,
+    type: CredentialType.KeyHash
+  });
+};
+var buildBip32PrivateKey = (entropy, password = "") => {
+  const PBKDF2_ITERATIONS = 4096;
+  const PBKDF2_KEY_SIZE = 96;
+  const PBKDF2_DIGEST_ALGORITHM = "sha512";
+  const clampScalar = (scalar) => {
+    if (scalar[0] !== void 0) {
+      scalar[0] &= 248;
+    }
+    if (scalar[31] !== void 0) {
+      scalar[31] &= 31;
+      scalar[31] |= 64;
+    }
+    return scalar;
+  };
+  const _entropy = Buffer.from(entropy, "hex");
+  const xprv = pbkdf2Sync(
+    password,
+    _entropy,
+    PBKDF2_ITERATIONS,
+    PBKDF2_KEY_SIZE,
+    PBKDF2_DIGEST_ALGORITHM
+  );
+  return Bip32PrivateKey3.fromBytes(clampScalar(xprv));
+};
+var buildRewardAddress = (networkId, stakeKeyHash) => {
+  const cred = {
+    type: CredentialType.KeyHash,
+    hash: stakeKeyHash
+  };
+  return RewardAddress.fromCredentials(networkId, cred);
+};
+var buildKeys = (entropy, accountIndex, keyIndex = 0) => {
+  if (typeof entropy === "string") {
+    const rootKey = new Bip32PrivateKey(Buffer.from(entropy, "hex"));
+    const accountKey = rootKey.derive(HARDENED_KEY_START + 1852).derive(HARDENED_KEY_START + 1815).derive(HARDENED_KEY_START + accountIndex);
+    const paymentKey = accountKey.derive(0).derive(keyIndex).toPrivateKey();
+    const stakeKey = accountKey.derive(2).derive(0).toPrivateKey();
+    return { paymentKey, stakeKey };
+  } else {
+    const paymentKey = new PrivateKey(Buffer.from(entropy[0], "hex"), false);
+    const stakeKey = new PrivateKey(Buffer.from(entropy[1], "hex"), false);
+    return { paymentKey, stakeKey };
+  }
+};
+var buildScriptPubkey = (keyHash) => {
+  const scriptPubkey = new ScriptPubkey(Ed25519KeyHashHex2(keyHash.hex()));
+  return NativeScript.newScriptPubkey(scriptPubkey);
+};
+
+// src/utils/converter.ts
+import { Serialization as Serialization2 } from "@cardano-sdk/core";
+import { Ed25519KeyHash as Ed25519KeyHash4 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob2 } from "@cardano-sdk/util";
+import {
+  toBytes as toBytes2
+} from "@meshsdk/common";
+
+// src/utils/deserializer.ts
+import { TxCBOR } from "@cardano-sdk/core";
+import { Ed25519KeyHashHex as Ed25519KeyHashHex3 } from "@cardano-sdk/crypto";
+import { HexBlob } 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 deserializeEd25519KeyHash = (ed25519KeyHash) => Ed25519KeyHash2.fromBytes(toBytes(ed25519KeyHash));
+var deserializeDataHash = (dataHash) => DatumHash.fromHexBlob(HexBlob(dataHash));
+var deserializePlutusData = (plutusData) => PlutusData.fromCbor(HexBlob(plutusData));
+var deserializePlutusScript = (plutusScript, version) => {
+  switch (version) {
+    case "V1":
+      return PlutusV1Script.fromCbor(HexBlob(plutusScript));
+    case "V2":
+      return PlutusV2Script.fromCbor(HexBlob(plutusScript));
+    case "V3":
+      return PlutusV3Script.fromCbor(HexBlob(plutusScript));
+    default:
+      throw new Error("Invalid Plutus script version");
+  }
+};
+var deserializeNativeScript = (nativeScript) => NativeScript.fromCbor(HexBlob(nativeScript));
+var deserializeScriptHash = (scriptHash) => ScriptHash.fromEd25519KeyHashHex(Ed25519KeyHashHex3(scriptHash));
+var deserializeScriptRef = (scriptRef) => Script.fromCbor(HexBlob(scriptRef));
+var deserializeTxUnspentOutput = (txUnspentOutput) => TransactionUnspentOutput.fromCbor(HexBlob(txUnspentOutput));
+var deserializeValue = (value) => Value.fromCbor(HexBlob(value));
+var deserializeTx = (tx) => Transaction.fromCbor(TxCBOR(tx));
+var deserializeTxHash = (txHash) => TransactionId.fromHexBlob(HexBlob(txHash));
+
+// src/utils/converter.ts
+var toAddress = (bech32) => Address.fromBech32(bech32);
+var toBaseAddress = (bech32) => {
+  return BaseAddress.fromAddress(toAddress(bech32));
+};
+var toEnterpriseAddress = (bech32) => {
+  return EnterpriseAddress.fromAddress(toAddress(bech32));
+};
+var toRewardAddress = (bech32) => RewardAddress.fromAddress(toAddress(bech32));
+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;
+  const plutusData = txUnspentOutput.output().datum()?.asInlineData() ? txUnspentOutput.output().datum()?.asInlineData()?.toCbor().toString() : void 0;
+  return {
+    input: {
+      outputIndex: Number(txUnspentOutput.input().index()),
+      txHash: txUnspentOutput.input().transactionId()
+    },
+    output: {
+      address: txUnspentOutput.output().address().toBech32(),
+      amount: fromValue(txUnspentOutput.output().amount()),
+      dataHash,
+      // todo not sure if correct
+      plutusData,
+      // todo not sure if correct
+      scriptRef
+      // todo not sure if correct
+    }
+  };
+};
+var toTxUnspentOutput = (utxo) => {
+  const txInput = new TransactionInput(
+    deserializeTxHash(utxo.input.txHash),
+    BigInt(utxo.input.outputIndex)
+  );
+  const txOutput = new TransactionOutput(
+    toAddress(utxo.output.address),
+    toValue(utxo.output.amount)
+  );
+  if (utxo.output.dataHash !== void 0) {
+    txOutput.setDatum(
+      Datum.fromCore(deserializeDataHash(utxo.output.dataHash))
+    );
+  }
+  if (utxo.output.plutusData !== void 0) {
+    const plutusData = deserializePlutusData(utxo.output.plutusData);
+    const datum = new Serialization2.Datum(void 0, plutusData);
+    txOutput.setDatum(datum);
+  }
+  if (utxo.output.scriptRef !== void 0) {
+    txOutput.setScriptRef(deserializeScriptRef(utxo.output.scriptRef));
+  }
+  return new TransactionUnspentOutput(txInput, txOutput);
+};
+var addressToBech32 = (address) => {
+  return address.toBech32();
+};
+var fromValue = (value) => {
+  const assets = [
+    { unit: "lovelace", quantity: value.coin().toString() }
+  ];
+  const multiAsset = value.multiasset();
+  if (multiAsset !== void 0) {
+    const _assets = Array.from(multiAsset.keys());
+    for (let i = 0; i < _assets.length; i += 1) {
+      const assetId = _assets[i];
+      if (assetId !== void 0) {
+        const assetQuantity = multiAsset.get(assetId);
+        if (assetQuantity !== void 0) {
+          assets.push({
+            unit: assetId,
+            quantity: assetQuantity.toString()
+          });
+        }
+      }
+    }
+  }
+  return assets;
+};
+var toScriptRef = (script) => {
+  if ("code" in script) {
+    const plutusScript = deserializePlutusScript(script.code, script.version);
+    if (plutusScript instanceof PlutusV1Script)
+      return Script.newPlutusV1Script(plutusScript);
+    if (plutusScript instanceof PlutusV2Script)
+      return Script.newPlutusV2Script(plutusScript);
+    if (plutusScript instanceof PlutusV3Script)
+      return Script.newPlutusV3Script(plutusScript);
+  }
+  return Script.newNativeScript(toNativeScript(script));
+};
+var fromScriptRef = (scriptRef) => {
+  const script = Script.fromCbor(HexBlob2(scriptRef));
+  const plutusScriptCodeV3 = script.asPlutusV3()?.toCbor().toString();
+  if (plutusScriptCodeV3) {
+    return {
+      code: plutusScriptCodeV3,
+      version: "V3"
+    };
+  }
+  const plutusScriptCodeV2 = script.asPlutusV2()?.toCbor().toString();
+  if (plutusScriptCodeV2) {
+    return {
+      code: plutusScriptCodeV2,
+      version: "V2"
+    };
+  }
+  const plutusScriptCodeV1 = script.asPlutusV1()?.toCbor().toString();
+  if (plutusScriptCodeV1) {
+    return {
+      code: plutusScriptCodeV1,
+      version: "V1"
+    };
+  }
+  const nativeScript = script.asNative();
+  if (!nativeScript) {
+    throw new Error("Invalid script");
+  }
+  return fromNativeScript(nativeScript);
+};
+var fromNativeScript = (script) => {
+  const fromNativeScripts = (scripts) => {
+    const nativeScripts = new Array();
+    for (let index = 0; index < scripts.length; index += 1) {
+      const script2 = scripts[index];
+      if (script2) {
+        nativeScripts.push(fromNativeScript(script2));
+      }
+    }
+    return nativeScripts;
+  };
+  switch (script.kind()) {
+    case RequireAllOf: {
+      const scriptAll = script.asScriptAll();
+      return {
+        type: "all",
+        scripts: fromNativeScripts(scriptAll.nativeScripts())
+      };
+    }
+    case RequireAnyOf: {
+      const scriptAny = script.asScriptAny();
+      return {
+        type: "any",
+        scripts: fromNativeScripts(scriptAny.nativeScripts())
+      };
+    }
+    case RequireNOf: {
+      const scriptNOfK = script.asScriptNOfK();
+      return {
+        type: "atLeast",
+        required: scriptNOfK.required(),
+        scripts: fromNativeScripts(scriptNOfK.nativeScripts())
+      };
+    }
+    case RequireTimeAfter: {
+      const timelockStart = script.asTimelockStart();
+      return {
+        type: "after",
+        slot: timelockStart.slot().toString()
+      };
+    }
+    case RequireTimeBefore: {
+      const timelockExpiry = script.asTimelockExpiry();
+      return {
+        type: "before",
+        slot: timelockExpiry.slot().toString()
+      };
+    }
+    case RequireSignature: {
+      const scriptPubkey = script.asScriptPubkey();
+      return {
+        type: "sig",
+        keyHash: scriptPubkey.keyHash().toString()
+      };
+    }
+    default:
+      throw new Error(`Script Kind: ${script.kind()}, is not supported`);
+  }
+};
+var toNativeScript = (script) => {
+  const toNativeScripts = (scripts) => {
+    const nativeScripts = [];
+    scripts.forEach((script2) => {
+      nativeScripts.push(toNativeScript(script2));
+    });
+    return nativeScripts;
+  };
+  switch (script.type) {
+    case "all":
+      return NativeScript.newScriptAll(
+        new Serialization2.ScriptAll(toNativeScripts(script.scripts))
+      );
+    case "any":
+      return NativeScript.newScriptAny(
+        new Serialization2.ScriptAny(toNativeScripts(script.scripts))
+      );
+    case "atLeast":
+      return NativeScript.newScriptNOfK(
+        new Serialization2.ScriptNOfK(
+          toNativeScripts(script.scripts),
+          script.required
+        )
+      );
+    case "after":
+      return NativeScript.newTimelockStart(
+        new Serialization2.TimelockStart(Slot(parseInt(script.slot)))
+      );
+    case "before":
+      return NativeScript.newTimelockExpiry(
+        new Serialization2.TimelockExpiry(Slot(parseInt(script.slot)))
+      );
+    case "sig":
+      return NativeScript.newScriptPubkey(
+        new Serialization2.ScriptPubkey(
+          Ed25519KeyHash4.fromBytes(toBytes2(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) => {
+    multiAsset.set(AssetId(asset.unit), BigInt(asset.quantity));
+  });
+  const lovelace = assets.find((asset) => asset.unit === "lovelace");
+  const value = new Value(BigInt(lovelace ? lovelace.quantity : 0));
+  if (assets.length > 1 || !lovelace) {
+    value.setMultiasset(multiAsset);
+  }
+  return value;
+};
+
+// src/utils/value.ts
+function mergeValue(a, b) {
+  const ma = a.multiasset() ?? /* @__PURE__ */ new Map();
+  b.multiasset()?.forEach((v, k) => {
+    const newVal = (ma.get(k) ?? 0n) + v;
+    if (newVal == 0n) {
+      ma.delete(k);
+    } else {
+      ma.set(k, newVal);
+    }
+  });
+  return new Value(
+    BigInt(a.coin()) + BigInt(b.coin()),
+    ma.size > 0 ? ma : void 0
+  );
+}
+function negateValue(v) {
+  const entries = v.multiasset()?.entries();
+  const tokenMap = /* @__PURE__ */ new Map();
+  if (entries) {
+    for (const entry of entries) {
+      tokenMap.set(entry[0], -entry[1]);
+    }
+  }
+  return new Value(-v.coin(), tokenMap);
+}
+function subValue(a, b) {
+  return mergeValue(a, negateValue(b));
+}
+function negatives(v) {
+  const entries = v.multiasset()?.entries();
+  const coin = v.coin() < 0n ? v.coin() : 0n;
+  const tokenMap = /* @__PURE__ */ new Map();
+  if (entries) {
+    for (const entry of entries) {
+      if (entry[1] < 0n) {
+        tokenMap.set(entry[0], entry[1]);
+      }
+    }
+  }
+  return new Value(coin, tokenMap);
+}
+function assetTypes(v) {
+  let count = v.coin() == 0n ? 0 : 1;
+  const entries = v.multiasset();
+  if (entries) {
+    entries.forEach(() => {
+      count += 1;
+    });
+  }
+  return count;
+}
+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();
+    throw new Error(
+      `Couldn't resolve payment key hash from address: ${bech32}`
+    );
+  } 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();
+};
+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}.`);
+  }
+};
+var resolvePoolId = (hash2) => {
+  return Ed25519KeyHashHex2(hash2).toString();
+};
+var resolvePrivateKey = (words) => {
+  return "not implemented";
+};
+var resolveScriptRef = (script) => {
+  return toScriptRef(script).toCbor().toString();
+};
+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 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}.`);
+  }
+};
+var resolveTxHash = (txHex) => {
+  const txBody = deserializeTx(txHex).body();
+  const hash2 = blake2b(blake2b.BYTES).update(hexToBytes(txBody.toCbor())).digest();
+  return Cardano2.TransactionId.fromHexBlob(HexBlob3.fromBytes(hash2));
+};
+
+// src/serializer/index.ts
+import { Serialization as Serialization4, TxCBOR as TxCBOR2 } from "@cardano-sdk/core";
+import { HexBlob as HexBlob5 } from "@cardano-sdk/util";
+import {
+  DEFAULT_V1_COST_MODEL_LIST,
+  DEFAULT_V2_COST_MODEL_LIST
+} from "@meshsdk/common";
+
+// src/utils/script-data-hash.ts
+import { Serialization as Serialization3 } from "@cardano-sdk/core";
+import * as Crypto2 from "@cardano-sdk/crypto";
+import { Hash32ByteBase16 as Hash32ByteBase163 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob4 } 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();
+  writer.writeStartArray(items.length);
+  for (const item of items) {
+    writer.writeEncodedValue(Buffer.from(item.toCbor(), "hex"));
+  }
+  return writer.encode();
+};
+var hashScriptData = (costModels, redemeers, datums) => {
+  const writer = new Serialization3.CborWriter();
+  if (datums && datums.length > 0 && (!redemeers || redemeers.length === 0)) {
+    writer.writeEncodedValue(CBOR_EMPTY_LIST);
+    writer.writeEncodedValue(getCborEncodedArray(datums));
+    writer.writeEncodedValue(CBOR_EMPTY_MAP);
+  } else {
+    if (!redemeers || redemeers.length === 0) return void 0;
+    writer.writeEncodedValue(getCborEncodedArray(redemeers));
+    if (datums && datums.length > 0)
+      writer.writeEncodedValue(getCborEncodedArray(datums));
+    writer.writeEncodedValue(
+      Buffer.from(costModels.languageViewsEncoding(), "hex")
+    );
+  }
+  return Hash32ByteBase163.fromHexBlob(
+    HexBlob4.fromBytes(
+      Crypto2.blake2b(Crypto2.blake2b.BYTES).update(writer.encode()).digest()
+    )
+  );
+};
+
+// src/serializer/index.ts
+var CardanoSDKSerializer = class {
+  constructor() {
+    this.utxoContext = /* @__PURE__ */ new Map();
+    this.redeemerContext = /* @__PURE__ */ new Map();
+    this.scriptsProvided = /* @__PURE__ */ new Set();
+    this.datumsProvided = /* @__PURE__ */ new Set();
+    this.usedLanguages = {
+      [0]: false,
+      [1]: false,
+      [2]: false
+    };
+    this.deserializer = {
+      key: {
+        deserializeAddress: function(bech32) {
+          throw new Error("Function not implemented.");
+        }
+      },
+      script: {
+        deserializeNativeScript: function(script) {
+          throw new Error("Function not implemented.");
+        },
+        deserializePlutusScript: function(script) {
+          throw new Error("Function not implemented.");
+        }
+      }
+    };
+    this.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);
+          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.");
+        },
+        resolveRewardAddress: function(bech32) {
+          throw new Error("Function not implemented.");
+        },
+        resolveEd25519KeyHash: function(bech32) {
+          throw new Error("Function not implemented.");
+        }
+      },
+      tx: {
+        resolveTxHash: function(txHex) {
+          return Transaction.fromCbor(TxCBOR2(txHex)).getId();
+        }
+      },
+      data: {
+        resolveDataHash: function(data) {
+          throw new Error("Function not implemented.");
+        }
+      },
+      script: {
+        // resolveNativeScript: function (script: CommonNativeScript): string {
+        //   return toNativeScript(script).toCbor();
+        // },
+        resolveScriptRef: function(script) {
+          throw new Error("Function not implemented.");
+        }
+      },
+      pool: {
+        resolvePoolId: function(hash2) {
+          throw new Error("Function not implemented.");
+        }
+      }
+    };
+    this.serializeTxBody = (txBuilderBody, protocolParams) => {
+      const {
+        inputs,
+        outputs,
+        extraInputs,
+        selectionThreshold,
+        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.addAllCollateralInputs(collaterals);
+      this.buildWitnessSet();
+      this.balanceTx(changeAddress, requiredSignatures.length, protocolParams);
+      return new Transaction(this.txBody, this.txWitnessSet).toCbor();
+    };
+    this.addSigningKeys = (txHex, signingKeys) => {
+      let cardanoTx = Transaction.fromCbor(TxCBOR2(txHex));
+      let currentWitnessSet = cardanoTx.witnessSet();
+      let currentWitnessSetVkeys = currentWitnessSet.vkeys();
+      let currentWitnessSetVkeysValues = currentWitnessSetVkeys ? [...currentWitnessSetVkeys.values()] : [];
+      for (let i = 0; i < signingKeys.length; i++) {
+        let keyHex = signingKeys[i];
+        if (keyHex) {
+          if (keyHex.length === 68 && keyHex.substring(0, 4) === "5820") {
+            keyHex = keyHex.substring(4);
+          }
+          const cardanoSigner = new PrivateKey(Buffer.from(keyHex, "hex"), false);
+          const signature = cardanoSigner.sign(
+            Buffer.from(cardanoTx.getId(), "hex")
+          );
+          currentWitnessSetVkeysValues.push(
+            new VkeyWitness(
+              Ed25519PublicKeyHex2(
+                cardanoSigner.toPublicKey().toBytes().toString("hex")
+              ),
+              Ed25519SignatureHex2(signature.toString("hex"))
+            )
+          );
+        }
+      }
+      currentWitnessSet.setVkeys(
+        Serialization4.CborSet.fromCore(
+          currentWitnessSetVkeysValues.map((vkw) => vkw.toCore()),
+          VkeyWitness.fromCore
+        )
+      );
+      cardanoTx.setWitnessSet(currentWitnessSet);
+      return cardanoTx.toCbor();
+    };
+    this.addAllInputs = (inputs) => {
+      for (let i = 0; i < inputs.length; i += 1) {
+        const currentTxIn = inputs[i];
+        if (!currentTxIn) continue;
+        switch (currentTxIn.type) {
+          case "PubKey":
+            this.addTxIn(currentTxIn);
+            break;
+          case "Script":
+            this.addScriptTxIn(
+              currentTxIn
+            );
+            break;
+        }
+      }
+    };
+    this.addTxIn = (currentTxIn) => {
+      let cardanoTxIn = new TransactionInput(
+        TransactionId(currentTxIn.txIn.txHash),
+        BigInt(currentTxIn.txIn.txIndex)
+      );
+      const inputs = this.txBody.inputs();
+      const txInputsList = [...inputs.values()];
+      if (txInputsList.find((input) => {
+        input.index() == cardanoTxIn.index() && input.transactionId == cardanoTxIn.transactionId;
+      })) {
+        throw new Error("Duplicate input added to tx body");
+      }
+      txInputsList.push(cardanoTxIn);
+      inputs.setValues(txInputsList);
+      const cardanoTxOut = new TransactionOutput(
+        Address.fromBech32(currentTxIn.txIn.address),
+        toValue(currentTxIn.txIn.amount)
+      );
+      this.utxoContext.set(cardanoTxIn, cardanoTxOut);
+      this.txBody.setInputs(inputs);
+    };
+    this.addScriptTxIn = (currentTxIn) => {
+      this.addTxIn({
+        type: "PubKey",
+        txIn: currentTxIn.txIn
+      });
+      if (!currentTxIn.scriptTxIn.scriptSource) {
+        throw new Error("A script input had no script source");
+      }
+      if (!currentTxIn.scriptTxIn.datumSource) {
+        throw new Error("A script input had no datum source");
+      }
+      if (!currentTxIn.scriptTxIn.redeemer) {
+        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(
+                  HexBlob5(currentTxIn.scriptTxIn.scriptSource.script.code)
+                )
+              )
+            );
+            this.usedLanguages[PlutusLanguageVersion.V1] = true;
+            break;
+          }
+          case "V2": {
+            this.scriptsProvided.add(
+              Script.newPlutusV2Script(
+                PlutusV2Script.fromCbor(
+                  HexBlob5(currentTxIn.scriptTxIn.scriptSource.script.code)
+                )
+              )
+            );
+            this.usedLanguages[PlutusLanguageVersion.V2] = true;
+            break;
+          }
+          case "V3": {
+            this.scriptsProvided.add(
+              Script.newPlutusV3Script(
+                PlutusV3Script.fromCbor(
+                  HexBlob5(currentTxIn.scriptTxIn.scriptSource.script.code)
+                )
+              )
+            );
+            this.usedLanguages[PlutusLanguageVersion.V3] = true;
+            break;
+          }
+        }
+      } else if (currentTxIn.scriptTxIn.scriptSource.type === "Inline") {
+        let referenceInputs = this.txBody.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;
+          }
+        }
+      }
+      if (currentTxIn.scriptTxIn.datumSource.type === "Provided") {
+        this.datumsProvided.add(
+          toPlutusData(currentTxIn.scriptTxIn.datumSource.data.content)
+          // TODO: handle json / raw datum
+        );
+      } else if (currentTxIn.scriptTxIn.datumSource.type === "Inline") {
+        let referenceInputs = this.txBody.referenceInputs() ? this.txBody.referenceInputs() : Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
+        let referenceInputsList = [...referenceInputs.values()];
+        referenceInputsList.push(
+          new TransactionInput(
+            TransactionId(currentTxIn.txIn.txHash),
+            BigInt(currentTxIn.txIn.txIndex)
+          )
+        );
+        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,
+        new Redeemer(
+          RedeemerTag.Spend,
+          BigInt(0),
+          toPlutusData(currentTxIn.scriptTxIn.redeemer.data.content),
+          // TODO: handle json / raw datum
+          new ExUnits(BigInt(exUnits.mem), BigInt(exUnits.steps))
+        )
+      );
+    };
+    this.addSimpleScriptTxIn = (currentTxIn) => {
+    };
+    this.addAllCollateralInputs = (collaterals) => {
+      for (let i = 0; i < collaterals.length; i++) {
+        this.addCollateralInput(
+          collaterals[i]
+        );
+      }
+    };
+    this.addCollateralInput = (collateral) => {
+      let cardanoTxIn = new TransactionInput(
+        TransactionId(collateral.txIn.txHash),
+        BigInt(collateral.txIn.txIndex)
+      );
+      const collateralInputs = this.txBody.collateral() ? this.txBody.collateral() : Serialization4.CborSet.fromCore([], TransactionInput.fromCore);
+      const collateralInputsList = [
+        ...collateralInputs.values()
+      ];
+      if (collateralInputsList.find((input) => {
+        input.index() == cardanoTxIn.index() && input.transactionId == cardanoTxIn.transactionId;
+      })) {
+        throw new Error("Duplicate input added to tx body");
+      }
+      collateralInputsList.push(cardanoTxIn);
+      collateralInputs.setValues(collateralInputsList);
+      const cardanoTxOut = new TransactionOutput(
+        Address.fromBech32(collateral.txIn.address),
+        toValue(collateral.txIn.amount)
+      );
+      this.utxoContext.set(cardanoTxIn, cardanoTxOut);
+      this.txBody.setCollateral(collateralInputs);
+    };
+    this.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));
+          }
+        }
+      }
+      let redeemers = this.txWitnessSet.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() ? this.txWitnessSet.nativeScripts() : Serialization4.CborSet.fromCore([], NativeScript.fromCore);
+      let v1Scripts = this.txWitnessSet.plutusV1Scripts() ? this.txWitnessSet.plutusV1Scripts() : Serialization4.CborSet.fromCore([], PlutusV1Script.fromCore);
+      let v2Scripts = this.txWitnessSet.plutusV2Scripts() ? this.txWitnessSet.plutusV2Scripts() : Serialization4.CborSet.fromCore([], PlutusV2Script.fromCore);
+      let v3Scripts = this.txWitnessSet.plutusV3Scripts() ? this.txWitnessSet.plutusV3Scripts() : Serialization4.CborSet.fromCore([], PlutusV3Script.fromCore);
+      this.scriptsProvided.forEach((script) => {
+        if (script.asNative() !== void 0) {
+          let nativeScriptsList = [...nativeScripts.values()];
+          nativeScriptsList.push(script.asNative());
+          nativeScripts.setValues(nativeScriptsList);
+        } else if (script.asPlutusV1() !== void 0) {
+          let v1ScriptsList = [...v1Scripts.values()];
+          v1ScriptsList.push(script.asPlutusV1());
+          v1Scripts.setValues(v1ScriptsList);
+        } else if (script.asPlutusV2() !== void 0) {
+          let v2ScriptsList = [...v2Scripts.values()];
+          v2ScriptsList.push(script.asPlutusV2());
+          v2Scripts.setValues(v2ScriptsList);
+        } else if (script.asPlutusV3() !== void 0) {
+          let v3ScriptsList = [...v3Scripts.values()];
+          v3ScriptsList.push(script.asPlutusV3());
+          v3Scripts.setValues(v3ScriptsList);
+        }
+        this.txWitnessSet.setNativeScripts(nativeScripts);
+        this.txWitnessSet.setPlutusV1Scripts(v1Scripts);
+        this.txWitnessSet.setPlutusV2Scripts(v2Scripts);
+        this.txWitnessSet.setPlutusV3Scripts(v3Scripts);
+      });
+      let datums = this.txWitnessSet.plutusData() ? this.txWitnessSet.plutusData() : Serialization4.CborSet.fromCore([], PlutusData.fromCore);
+      this.datumsProvided.forEach((datum) => {
+        let datumsList = [...datums.values()];
+        datumsList.push(datum);
+        datums.setValues(datumsList);
+      });
+      this.txWitnessSet.setPlutusData(datums);
+      let costModelV1 = Serialization4.CostModel.newPlutusV1(
+        DEFAULT_V1_COST_MODEL_LIST
+      );
+      let costModelV2 = Serialization4.CostModel.newPlutusV2(
+        DEFAULT_V2_COST_MODEL_LIST
+      );
+      let costModels = new Serialization4.Costmdls();
+      if (this.usedLanguages[PlutusLanguageVersion.V1]) {
+        costModels.insert(costModelV1);
+      }
+      if (this.usedLanguages[PlutusLanguageVersion.V2]) {
+        costModels.insert(costModelV2);
+      }
+      if (this.usedLanguages[PlutusLanguageVersion.V3]) {
+      }
+      let scriptDataHash = hashScriptData(
+        costModels,
+        redeemers.size() > 0 ? [...redeemers.values()] : void 0,
+        datums.size() > 0 ? [...datums.values()] : void 0
+      );
+      if (scriptDataHash) {
+        this.txBody.setScriptDataHash(scriptDataHash);
+      }
+    };
+    this.balanceTx = (changeAddress, numberOfRequiredWitnesses, protocolParams) => {
+      if (changeAddress === "") {
+        throw new Error("Can't balance tx without a change address");
+      }
+      const inputs = this.txBody.inputs().values();
+      let remainingValue = new Value(BigInt(0));
+      for (let i = 0; i < inputs.length; i++) {
+        let input = inputs[i];
+        if (!input) {
+          throw new Error("Invalid input found");
+        }
+        const output = this.utxoContext.get(input);
+        if (!output) {
+          throw new Error(`Unable to resolve input: ${input.toCbor()}`);
+        }
+        remainingValue = mergeValue(remainingValue, output.amount());
+      }
+      const withdrawals = this.txBody.withdrawals();
+      if (withdrawals) {
+        withdrawals.forEach((coin) => {
+          remainingValue = mergeValue(remainingValue, new Value(coin));
+        });
+      }
+      remainingValue = mergeValue(
+        remainingValue,
+        new Value(BigInt(0), this.txBody.mint())
+      );
+      const currentOutputs = this.txBody.outputs();
+      for (let i = 0; i < currentOutputs.length; i++) {
+        let output = currentOutputs.at(i);
+        if (output) {
+          remainingValue = subValue(remainingValue, output.amount());
+        }
+      }
+      if (remainingValue.coin() < 0 || !empty(negatives(remainingValue))) {
+        throw new Error(`Not enough funds to satisfy outputs`);
+      }
+      currentOutputs.push(
+        new TransactionOutput(Address.fromBech32(changeAddress), remainingValue)
+      );
+      this.txBody.setOutputs(currentOutputs);
+      this.txBody.setFee(BigInt("10000000"));
+      const dummyTx = this.createDummyTx(numberOfRequiredWitnesses);
+      const fee = protocolParams.minFeeB + dummyTx.toCbor().length / 2 * Number(protocolParams.coinsPerUtxoSize);
+      this.txBody.setFee(BigInt(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);
+      this.txBody.setOutputs(currentOutputs);
+    };
+    this.createDummyTx = (numberOfRequiredWitnesses) => {
+      let dummyWitnessSet = new TransactionWitnessSet();
+      const dummyVkeyWitnesses = [];
+      for (let i = 0; i < numberOfRequiredWitnesses; i++) {
+        dummyVkeyWitnesses.push([
+          Ed25519PublicKeyHex2("0".repeat(64)),
+          Ed25519SignatureHex2("0".repeat(128))
+        ]);
+      }
+      dummyWitnessSet.setVkeys(
+        Serialization4.CborSet.fromCore(dummyVkeyWitnesses, VkeyWitness.fromCore)
+      );
+      return new Transaction(this.txBody, dummyWitnessSet);
+    };
+    this.txBody = new TransactionBody(
+      Serialization4.CborSet.fromCore([], TransactionInput.fromCore),
+      [],
+      BigInt(0),
+      void 0
+    );
+    this.txWitnessSet = new TransactionWitnessSet();
+  }
+  serializeAddress(address, networkId) {
+    throw new Error("Method not implemented.");
+  }
+  serializeData(data) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/index.ts
+import * as CardanoSDKUtil from "@cardano-sdk/util";
+import * as Crypto3 from "@cardano-sdk/crypto";
+import * as CardanoSDK from "@cardano-sdk/core";
+export {
+  Address,
+  AddressType,
+  AssetFingerprint,
+  AssetId,
+  AssetName,
+  BaseAddress,
+  Bip32PrivateKey3 as Bip32PrivateKey,
+  Bip32PrivateKeyHex2 as Bip32PrivateKeyHex,
+  Cardano4 as Cardano,
+  CardanoSDK,
+  CardanoSDKSerializer,
+  CardanoSDKUtil,
+  CborSet,
+  CborWriter,
+  Certificate,
+  CertificateType,
+  ConstrPlutusData,
+  CostModel,
+  Costmdls,
+  Credential,
+  CredentialType,
+  Crypto3 as Crypto,
+  Datum,
+  DatumHash,
+  DatumKind,
+  Ed25519KeyHash2 as Ed25519KeyHash,
+  Ed25519KeyHashHex2 as Ed25519KeyHashHex,
+  Ed25519PrivateExtendedKeyHex,
+  Ed25519PrivateNormalKeyHex,
+  Ed25519PublicKey2 as Ed25519PublicKey,
+  Ed25519PublicKeyHex2 as Ed25519PublicKeyHex,
+  Ed25519Signature2 as Ed25519Signature,
+  Ed25519SignatureHex2 as Ed25519SignatureHex,
+  EnterpriseAddress,
+  ExUnits,
+  Hash,
+  Hash28ByteBase162 as Hash28ByteBase16,
+  Hash32ByteBase162 as Hash32ByteBase16,
+  NativeScript,
+  NetworkId,
+  PaymentAddress,
+  PlutusData,
+  PlutusLanguageVersion,
+  PlutusList,
+  PlutusMap,
+  PlutusV1Script,
+  PlutusV2Script,
+  PlutusV3Script,
+  PolicyId,
+  PoolId,
+  PrivateKey,
+  PublicKey,
+  Redeemer,
+  RedeemerPurpose,
+  RedeemerTag,
+  Redeemers,
+  RequireAllOf,
+  RequireAnyOf,
+  RequireNOf,
+  RequireSignature,
+  RequireTimeAfter,
+  RequireTimeBefore,
+  RewardAccount,
+  RewardAddress,
+  Script,
+  ScriptHash,
+  ScriptPubkey,
+  Serialization5 as Serialization,
+  Slot,
+  StakeDelegation,
+  StakeRegistration,
+  Transaction,
+  TransactionBody,
+  TransactionId,
+  TransactionInput,
+  TransactionOutput,
+  TransactionUnspentOutput,
+  TransactionWitnessSet,
+  Value,
+  VkeyWitness,
+  VrfVkBech32,
+  addressToBech32,
+  assetTypes,
+  buildBaseAddress,
+  buildBip32PrivateKey,
+  buildEnterpriseAddress,
+  buildKeys,
+  buildRewardAddress,
+  buildScriptPubkey,
+  checkSignature,
+  deserializeAddress,
+  deserializeDataHash,
+  deserializeEd25519KeyHash,
+  deserializeNativeScript,
+  deserializePlutusData,
+  deserializePlutusScript,
+  deserializeScriptHash,
+  deserializeScriptRef,
+  deserializeTx,
+  deserializeTxHash,
+  deserializeTxUnspentOutput,
+  deserializeValue,
+  empty,
+  fromNativeScript,
+  fromScriptRef,
+  fromTxUnspentOutput,
+  fromValue,
+  mergeValue,
+  negateValue,
+  negatives,
+  resolveDataHash,
+  resolveNativeScriptAddress,
+  resolveNativeScriptHash,
+  resolvePaymentKeyHash,
+  resolvePlutusScriptAddress,
+  resolvePlutusScriptHash,
+  resolvePoolId,
+  resolvePrivateKey,
+  resolveRewardAddress,
+  resolveScriptRef,
+  resolveStakeKeyHash,
+  resolveTxHash,
+  signData,
+  subValue,
+  toAddress,
+  toBaseAddress,
+  toEnterpriseAddress,
+  toNativeScript,
+  toPlutusData,
+  toRewardAddress,
+  toScriptRef,
+  toTxUnspentOutput,
+  toValue
+};