@hydrawallet-sdk/core 0.0.2

package/dist/index.js

@@ -0,0 +1,1339 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AppWallet: () => AppWallet,
+  ChainDerivation: () => ChainDerivation,
+  CoinTypes: () => CoinTypes,
+  DEFAULT_PROTOCOL_PARAMETERS: () => DEFAULT_PROTOCOL_PARAMETERS,
+  DEFAULT_V1_COST_MODEL_LIST: () => DEFAULT_V1_COST_MODEL_LIST,
+  DEFAULT_V2_COST_MODEL_LIST: () => DEFAULT_V2_COST_MODEL_LIST,
+  DEFAULT_V3_COST_MODEL_LIST: () => DEFAULT_V3_COST_MODEL_LIST,
+  DREP_DEPOSIT: () => DREP_DEPOSIT,
+  EmbeddedWallet: () => EmbeddedWallet,
+  HARDENED_KEY_START: () => HARDENED_KEY_START,
+  LANGUAGE_VERSIONS: () => LANGUAGE_VERSIONS,
+  NETWORK_ID: () => NETWORK_ID,
+  NETWORK_MAGIC: () => NETWORK_MAGIC,
+  PLACEHOLDER_ADDRESS: () => PLACEHOLDER_ADDRESS,
+  Purpose: () => Purpose,
+  WalletStaticMethods: () => WalletStaticMethods,
+  buildBaseAddress: () => buildBaseAddress,
+  buildDRepID: () => buildDRepID,
+  buildEnterpriseAddress: () => buildEnterpriseAddress,
+  buildKeys: () => buildKeys,
+  buildRewardAddress: () => buildRewardAddress,
+  bytesToHex: () => bytesToHex,
+  castProtocol: () => castProtocol,
+  clampScalar: () => clampScalar,
+  convertUTxOObjectToUTxO: () => convertUTxOObjectToUTxO,
+  convertUTxOToUTxOObject: () => convertUTxOToUTxOObject,
+  deserializeAssetUnit: () => deserializeAssetUnit,
+  deserializeTx: () => deserializeTx,
+  fromUTF8: () => fromUTF8,
+  fungibleAssetKeys: () => fungibleAssetKeys,
+  hexToBytes: () => hexToBytes,
+  hexToString: () => hexToString,
+  mergeAssets: () => mergeAssets,
+  metadataStandardKeys: () => metadataStandardKeys,
+  metadataToCip68: () => metadataToCip68,
+  resolveTxBodyHash: () => resolveTxBodyHash,
+  resolveTxFees: () => resolveTxFees,
+  resolveTxHash: () => resolveTxHash,
+  royaltiesStandardKeys: () => royaltiesStandardKeys,
+  serializeAssetUnit: () => serializeAssetUnit,
+  stringToHex: () => stringToHex,
+  stripExtendedKey: () => stripExtendedKey,
+  toBytes: () => toBytes,
+  toUTF8: () => toUTF8
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/embedded.ts
+var BaseEncoding = __toESM(require("@scure/base"));
+var import_bip39 = require("bip39");
+var import_cardano_wasm4 = require("@hydrawallet-sdk/cardano-wasm");
+
+// src/utils/cardano-wasm/build-keys.ts
+var import_cardano_wasm2 = require("@hydrawallet-sdk/cardano-wasm");
+
+// src/constants/chain.ts
+var import_cardano_wasm = require("@hydrawallet-sdk/cardano-wasm");
+var NETWORK_ID = {
+  MAINNET: import_cardano_wasm.CardanoWASM.NetworkInfo.mainnet().network_id(),
+  PREPROD: import_cardano_wasm.CardanoWASM.NetworkInfo.testnet_preprod().network_id(),
+  PREVIEW: import_cardano_wasm.CardanoWASM.NetworkInfo.testnet_preview().network_id()
+};
+var NETWORK_MAGIC = {
+  MAINNET: import_cardano_wasm.CardanoWASM.NetworkInfo.mainnet().protocol_magic(),
+  PREPROD: import_cardano_wasm.CardanoWASM.NetworkInfo.testnet_preprod().protocol_magic(),
+  PREVIEW: import_cardano_wasm.CardanoWASM.NetworkInfo.testnet_preview().protocol_magic()
+};
+
+// src/utils/cardano-wasm/build-keys.ts
+var buildBaseAddress = (networkId, paymentKeyHash, stakeKeyHash) => {
+  const paymentCredential = import_cardano_wasm2.CardanoWASM.Credential.from_keyhash(paymentKeyHash);
+  const stakeCredential = import_cardano_wasm2.CardanoWASM.Credential.from_keyhash(stakeKeyHash);
+  return import_cardano_wasm2.CardanoWASM.BaseAddress.new(networkId, paymentCredential, stakeCredential);
+};
+var buildEnterpriseAddress = (networkId, paymentKeyHash) => {
+  const paymentCredential = import_cardano_wasm2.CardanoWASM.Credential.from_keyhash(paymentKeyHash);
+  return import_cardano_wasm2.CardanoWASM.EnterpriseAddress.new(networkId, paymentCredential);
+};
+var buildRewardAddress = (networkId, stakeKeyHash) => {
+  const stakeCredential = import_cardano_wasm2.CardanoWASM.Credential.from_keyhash(stakeKeyHash);
+  return import_cardano_wasm2.CardanoWASM.RewardAddress.new(networkId, stakeCredential);
+};
+var buildDRepID = (dRepKey, networkId = NETWORK_ID.MAINNET) => {
+  console.log("buildDRepID", dRepKey.to_hex(), networkId);
+  return null;
+};
+var Purpose = /* @__PURE__ */ ((Purpose2) => {
+  Purpose2[Purpose2["CIP1852"] = 1852] = "CIP1852";
+  return Purpose2;
+})(Purpose || {});
+var CoinTypes = /* @__PURE__ */ ((CoinTypes2) => {
+  CoinTypes2[CoinTypes2["CARDANO"] = 1815] = "CARDANO";
+  return CoinTypes2;
+})(CoinTypes || {});
+var ChainDerivation = /* @__PURE__ */ ((ChainDerivation2) => {
+  ChainDerivation2[ChainDerivation2["EXTERNAL"] = 0] = "EXTERNAL";
+  ChainDerivation2[ChainDerivation2["INTERNAL"] = 1] = "INTERNAL";
+  ChainDerivation2[ChainDerivation2["CHIMERIC"] = 2] = "CHIMERIC";
+  ChainDerivation2[ChainDerivation2["DREP"] = 3] = "DREP";
+  return ChainDerivation2;
+})(ChainDerivation || {});
+function harden(num) {
+  return 2147483648 + num;
+}
+var buildKeys = (privateKeyHex, accountIndex, keyIndex = 0) => {
+  if (Array.isArray(privateKeyHex)) {
+    return {
+      // TODO: need to verify this
+      accountKey: import_cardano_wasm2.CardanoWASM.Bip32PrivateKey.from_hex(privateKeyHex[0]),
+      paymentKey: import_cardano_wasm2.CardanoWASM.Bip32PrivateKey.from_hex(privateKeyHex[0]),
+      stakeKey: import_cardano_wasm2.CardanoWASM.Bip32PrivateKey.from_hex(privateKeyHex[1])
+    };
+  }
+  const privateKey = import_cardano_wasm2.CardanoWASM.Bip32PrivateKey.from_hex(privateKeyHex);
+  const accountKey = privateKey.derive(harden(1852 /* CIP1852 */)).derive(harden(1815 /* CARDANO */)).derive(harden(accountIndex));
+  const paymentKey = accountKey.derive(0 /* EXTERNAL */).derive(keyIndex);
+  const stakeKey = accountKey.derive(2 /* CHIMERIC */).derive(keyIndex);
+  const dRepKey = accountKey.derive(3 /* DREP */).derive(keyIndex);
+  return { accountKey, paymentKey, stakeKey, dRepKey };
+};
+var clampScalar = (scalar) => {
+  if (scalar[0] !== void 0) {
+    scalar[0] &= 248;
+  }
+  if (scalar[31] !== void 0) {
+    scalar[31] &= 31;
+    scalar[31] |= 64;
+  }
+  return scalar;
+};
+var stripExtendedKey = (extendedKeyHex) => {
+  if (extendedKeyHex.length !== 192) {
+    throw new Error("Extended key must be 192 hex characters (96 bytes)");
+  }
+  const strippedKeyHex = extendedKeyHex.slice(0, 128);
+  return strippedKeyHex;
+};
+
+// src/utils/cardano-wasm/resolver.ts
+var import_cardano_wasm3 = require("@hydrawallet-sdk/cardano-wasm");
+var resolveTxHash = (cborHex) => {
+  return import_cardano_wasm3.CardanoWASM.FixedTransaction.from_hex(cborHex).transaction_hash().to_hex();
+};
+var resolveTxBodyHash = (txBody) => {
+  const tx = import_cardano_wasm3.CardanoWASM.FixedTransaction.new_from_body_bytes(txBody.to_bytes());
+  return tx.transaction_hash();
+};
+
+// src/utils/parser.ts
+var bytesToHex = (bytes) => {
+  if (Buffer.isBuffer(bytes)) {
+    return bytes.toString("hex");
+  }
+  if (bytes instanceof ArrayBuffer) {
+    return Buffer.from(bytes).toString("hex");
+  }
+  return Buffer.from(bytes).toString("hex");
+};
+var hexToBytes = (hex) => Buffer.from(hex, "hex");
+var stringToHex = (str) => Buffer.from(str, "utf8").toString("hex");
+var hexToString = (hex) => Buffer.from(hex, "hex").toString("utf8");
+var toBytes = (hex) => {
+  if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex))
+    return Buffer.from(hex, "hex");
+  return Buffer.from(hex, "utf-8");
+};
+var fromUTF8 = (utf8) => {
+  return Buffer.from(utf8, "utf-8").toString("hex");
+};
+var toUTF8 = (hex) => Buffer.from(hex, "hex").toString("utf-8");
+
+// src/embedded.ts
+var WalletStaticMethods = class {
+  static privateKeyBech32ToPrivateKeyHex(_bech32) {
+    const bech32DecodedBytes = BaseEncoding.bech32.decodeToBytes(_bech32).bytes;
+    const bip32PrivateKey = import_cardano_wasm4.CardanoWASM.Bip32PrivateKey.from_bytes(bech32DecodedBytes);
+    return bip32PrivateKey.to_hex();
+  }
+  static mnemonicToPrivateKeyHex(words, password = "") {
+    const entropy = (0, import_bip39.mnemonicToEntropy)(words.join(" "));
+    const bip32PrivateKey = import_cardano_wasm4.CardanoWASM.Bip32PrivateKey.from_bip39_entropy(toBytes(entropy), toBytes(password));
+    return bip32PrivateKey.to_hex();
+  }
+  static privateKeyHexToBech32(privateKeyHex) {
+    const bip32PrivateKey = import_cardano_wasm4.CardanoWASM.Bip32PrivateKey.from_hex(privateKeyHex);
+    return bip32PrivateKey.to_bech32();
+  }
+  static signingKeyToHexes(paymentKey, stakeKey) {
+    return [
+      paymentKey.startsWith("5820") ? paymentKey.slice(4) : paymentKey,
+      stakeKey.startsWith("5820") ? stakeKey.slice(4) : stakeKey
+    ];
+  }
+  static bip32BytesToPrivateKeyHex(bip32Bytes) {
+    const bip32PrivateKey = import_cardano_wasm4.CardanoWASM.Bip32PrivateKey.from_bytes(bip32Bytes);
+    return bip32PrivateKey.to_hex();
+  }
+  static getAddresses(paymentKey, stakingKey, networkId = 0) {
+    const baseAddress = buildBaseAddress(
+      networkId,
+      paymentKey.to_public().to_raw_key().hash(),
+      stakingKey.to_public().to_raw_key().hash()
+    ).to_address();
+    const enterpriseAddress = buildEnterpriseAddress(networkId, paymentKey.to_public().to_raw_key().hash()).to_address();
+    const rewardAddress = buildRewardAddress(networkId, stakingKey.to_public().to_raw_key().hash()).to_address();
+    return {
+      baseAddress,
+      enterpriseAddress,
+      rewardAddress
+    };
+  }
+  static generateMnemonic(strength = 256) {
+    const mnemonic = (0, import_bip39.generateMnemonic)(strength);
+    return mnemonic.split(" ");
+  }
+  // static getDRepKey(
+  //   dRepKey: Ed25519PrivateKey,
+  //   networkId = 0
+  // ): {
+  //   pubDRepKey: string
+  //   dRepIDBech32: DRepID
+  //   dRepIDHash: Ed25519KeyHashHex
+  // } {
+  //   const pubDRepKey = dRepKey.toPublic().hex().toString()
+  //   const dRepIDBech32 = buildDRepID(Ed25519PublicKeyHex(pubDRepKey), networkId)
+  //   const dRep = DRep.newKeyHash(dRepKey.toPublic().hash().hex())
+  //   const dRepIDHash = dRep.toKeyHash()!
+  //   return {
+  //     pubDRepKey,
+  //     dRepIDBech32,
+  //     dRepIDHash
+  //   }
+  // }
+};
+var EmbeddedWallet = class extends WalletStaticMethods {
+  constructor(options) {
+    super();
+    this._networkId = options.networkId;
+    switch (options.key.type) {
+      case "mnemonic":
+        this._walletSecret = WalletStaticMethods.mnemonicToPrivateKeyHex(options.key.words);
+        break;
+      case "root":
+        this._walletSecret = WalletStaticMethods.privateKeyBech32ToPrivateKeyHex(options.key.bech32);
+        break;
+      case "cli":
+        this._walletSecret = WalletStaticMethods.signingKeyToHexes(
+          options.key.payment,
+          options.key.stake ?? "f0".repeat(32)
+        );
+        break;
+      case "bip32Bytes":
+        this._walletSecret = WalletStaticMethods.bip32BytesToPrivateKeyHex(options.key.bip32Bytes);
+        break;
+    }
+  }
+  getPrivateKeyHex() {
+    if (this._walletSecret == void 0)
+      throw new Error("[EmbeddedWallet] No keys initialized");
+    return this._walletSecret;
+  }
+  getAccount(accountIndex = 0, keyIndex = 0) {
+    if (this._walletSecret == void 0)
+      throw new Error("[EmbeddedWallet] No keys initialized");
+    const { paymentKey, stakeKey } = buildKeys(this._walletSecret, accountIndex, keyIndex);
+    const { baseAddress, enterpriseAddress, rewardAddress } = WalletStaticMethods.getAddresses(
+      paymentKey,
+      stakeKey,
+      this._networkId
+    );
+    const _account = {
+      baseAddress,
+      enterpriseAddress,
+      rewardAddress,
+      baseAddressBech32: baseAddress.to_bech32(),
+      enterpriseAddressBech32: enterpriseAddress.to_bech32(),
+      rewardAddressBech32: rewardAddress.to_bech32(),
+      paymentKey,
+      stakeKey,
+      paymentKeyHex: stripExtendedKey(paymentKey.to_hex()),
+      stakeKeyHex: stripExtendedKey(stakeKey.to_hex()),
+      extendedPaymentKeyHex: paymentKey.to_hex(),
+      extendedStakeKeyHex: stakeKey.to_hex()
+    };
+    return _account;
+  }
+  /**
+   * Get wallet network ID.
+   *
+   * @returns network ID
+   */
+  getNetworkId() {
+    return this._networkId;
+  }
+  /**
+   * This endpoints sign the provided transaction (unsignedTx) with the private key of the owner.
+   *
+   * @param unsignedTx - a transaction in CBOR
+   * @param accountIndex account index (default: 0)
+   * @param keyIndex key index (default: 0)
+   * @returns VkeyWitness
+   */
+  signTx(unsignedTx, accountIndex = 0, keyIndex = 0) {
+    try {
+      const txHashHex = resolveTxHash(unsignedTx);
+      const { paymentKey } = this.getAccount(accountIndex, keyIndex);
+      const privateSigningKey = paymentKey.to_raw_key();
+      const vkeyWitness = import_cardano_wasm4.CardanoWASM.make_vkey_witness(import_cardano_wasm4.CardanoWASM.TransactionHash.from_hex(txHashHex), privateSigningKey);
+      return vkeyWitness;
+    } catch (error) {
+      throw new Error(`[EmbeddedWallet] An error occurred during signTx: ${error}.`);
+    }
+  }
+  //   /**
+  //    * This endpoint utilizes the [CIP-8 - Message Signing](https://cips.cardano.org/cips/cip8/) to sign arbitrary data, to verify the data was signed by the owner of the private key.
+  //    *
+  //    * @param address - bech32 address to sign the data with
+  //    * @param payload - the data to be signed
+  //    * @param accountIndex account index (default: 0)
+  //    * @returns a signature
+  //    */
+  //   signData(address: string, payload: string, accountIndex = 0, keyIndex = 0): DataSignature {
+  //     try {
+  //       const { baseAddress, enterpriseAddress, rewardAddress, paymentKey } = this.getAccount(accountIndex, keyIndex)
+  //       const foundAddress = [baseAddress, enterpriseAddress, rewardAddress].find(a => a.toBech32() === address)
+  //       if (foundAddress === undefined)
+  //         throw new Error(`[EmbeddedWallet] Address: ${address} doesn't belong to this account.`)
+  //       // todo tw
+  //       return signData(payload, {
+  //         address: Address.fromBech32(address),
+  //         key: paymentKey
+  //       })
+  //     } catch (error) {
+  //       throw new Error(`[EmbeddedWallet] An error occurred during signData: ${error}.`)
+  //     }
+  //   }
+};
+
+// src/utils/cardano-wasm/deserializer.ts
+var import_cardano_wasm5 = require("@hydrawallet-sdk/cardano-wasm");
+var deserializeTx = (txCborHex) => {
+  return import_cardano_wasm5.CardanoWASM.FixedTransaction.from_bytes(Buffer.from(txCborHex, "hex"));
+};
+var deserializeAssetUnit = (assetUnit) => {
+  const policyId = assetUnit.substring(0, 56);
+  const assetName = assetUnit.substring(56);
+  return { policyId, assetName };
+};
+
+// src/wallet.ts
+var AppWallet = class {
+  constructor(options) {
+    this._fetcher = options.fetcher;
+    this._submitter = options.submitter;
+    switch (options.key.type) {
+      case "mnemonic":
+        this._wallet = new EmbeddedWallet({
+          networkId: options.networkId,
+          key: {
+            type: "mnemonic",
+            words: options.key.words
+          }
+        });
+        break;
+      case "root":
+        this._wallet = new EmbeddedWallet({
+          networkId: options.networkId,
+          key: {
+            type: "root",
+            bech32: options.key.bech32
+          }
+        });
+        break;
+      case "cli":
+        this._wallet = new EmbeddedWallet({
+          networkId: options.networkId,
+          key: {
+            type: "cli",
+            payment: options.key.payment,
+            stake: options.key.stake
+          }
+        });
+    }
+  }
+  getAccount(accountIndex = 0, keyIndex = 0) {
+    return this._wallet.getAccount(accountIndex, keyIndex);
+  }
+  getEnterpriseAddress(accountIndex = 0, keyIndex = 0) {
+    const account = this._wallet.getAccount(accountIndex, keyIndex);
+    return account.enterpriseAddressBech32;
+  }
+  getPaymentAddress(accountIndex = 0, keyIndex = 0) {
+    const account = this._wallet.getAccount(accountIndex, keyIndex);
+    return account.baseAddressBech32;
+  }
+  getRewardAddress(accountIndex = 0, keyIndex = 0) {
+    const account = this._wallet.getAccount(accountIndex, keyIndex);
+    return account.rewardAddressBech32;
+  }
+  getNetworkId() {
+    return this._wallet.getNetworkId();
+  }
+  async signTx(unsignedTx, partialSign = false, accountIndex = 0, keyIndex = 0) {
+    try {
+      const tx = deserializeTx(unsignedTx);
+      if (!partialSign && tx.witness_set().vkeys() !== void 0 && tx.witness_set().vkeys()?.len() !== 0)
+        throw new Error("Signatures already exist in the transaction in a non partial sign call");
+      const prvSigningKey = this._wallet.getAccount(accountIndex, keyIndex).paymentKey.to_raw_key();
+      tx.sign_and_add_vkey_signature(prvSigningKey);
+      return tx.to_hex();
+    } catch (error) {
+      throw new Error(`[AppWallet] An error occurred during signTx: ${error}.`);
+    }
+  }
+  static brew(strength = 256) {
+    return EmbeddedWallet.generateMnemonic(strength);
+  }
+  async signData(address, payload, accountIndex = 0, keyIndex = 0) {
+    try {
+      console.log(">>> signData", address, payload, accountIndex, keyIndex);
+      return new Promise(() => {
+        throw new Error(`[AppWallet] signData() is not implemented.`);
+      });
+    } catch (error) {
+      throw new Error(`[AppWallet] An error occurred during signData: ${error}.`);
+    }
+  }
+  signTxs(unsignedTxs, partialSign) {
+    console.log(">>> signTxs", unsignedTxs, partialSign);
+    throw new Error(`[AppWallet] signTxs() is not implemented.`);
+  }
+  submitTx(tx) {
+    console.log(">>> submitTx", tx);
+    throw new Error(`[AppWallet] submitTx() is not implemented.`);
+  }
+};
+
+// src/constants/cost-models.ts
+var DEFAULT_V1_COST_MODEL_LIST = [
+  100788,
+  420,
+  1,
+  1,
+  1e3,
+  173,
+  0,
+  1,
+  1e3,
+  59957,
+  4,
+  1,
+  11183,
+  32,
+  201305,
+  8356,
+  4,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  100,
+  100,
+  16e3,
+  100,
+  94375,
+  32,
+  132994,
+  32,
+  61462,
+  4,
+  72010,
+  178,
+  0,
+  1,
+  22151,
+  32,
+  91189,
+  769,
+  4,
+  2,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  1e3,
+  42921,
+  4,
+  2,
+  24548,
+  29498,
+  38,
+  1,
+  898148,
+  27279,
+  1,
+  51775,
+  558,
+  1,
+  39184,
+  1e3,
+  60594,
+  1,
+  141895,
+  32,
+  83150,
+  32,
+  15299,
+  32,
+  76049,
+  1,
+  13169,
+  4,
+  22100,
+  10,
+  28999,
+  74,
+  1,
+  28999,
+  74,
+  1,
+  43285,
+  552,
+  1,
+  44749,
+  541,
+  1,
+  33852,
+  32,
+  68246,
+  32,
+  72362,
+  32,
+  7243,
+  32,
+  7391,
+  32,
+  11546,
+  32,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  90434,
+  519,
+  0,
+  1,
+  74433,
+  32,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  270652,
+  22588,
+  4,
+  1457325,
+  64566,
+  4,
+  20467,
+  1,
+  4,
+  0,
+  141992,
+  32,
+  100788,
+  420,
+  1,
+  1,
+  81663,
+  32,
+  59498,
+  32,
+  20142,
+  32,
+  24588,
+  32,
+  20744,
+  32,
+  25933,
+  32,
+  24623,
+  32,
+  53384111,
+  14333,
+  10
+];
+var DEFAULT_V2_COST_MODEL_LIST = [
+  100788,
+  420,
+  1,
+  1,
+  1e3,
+  173,
+  0,
+  1,
+  1e3,
+  59957,
+  4,
+  1,
+  11183,
+  32,
+  201305,
+  8356,
+  4,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  100,
+  100,
+  16e3,
+  100,
+  94375,
+  32,
+  132994,
+  32,
+  61462,
+  4,
+  72010,
+  178,
+  0,
+  1,
+  22151,
+  32,
+  91189,
+  769,
+  4,
+  2,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  1e3,
+  42921,
+  4,
+  2,
+  24548,
+  29498,
+  38,
+  1,
+  898148,
+  27279,
+  1,
+  51775,
+  558,
+  1,
+  39184,
+  1e3,
+  60594,
+  1,
+  141895,
+  32,
+  83150,
+  32,
+  15299,
+  32,
+  76049,
+  1,
+  13169,
+  4,
+  22100,
+  10,
+  28999,
+  74,
+  1,
+  28999,
+  74,
+  1,
+  43285,
+  552,
+  1,
+  44749,
+  541,
+  1,
+  33852,
+  32,
+  68246,
+  32,
+  72362,
+  32,
+  7243,
+  32,
+  7391,
+  32,
+  11546,
+  32,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  90434,
+  519,
+  0,
+  1,
+  74433,
+  32,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  85848,
+  228465,
+  122,
+  0,
+  1,
+  1,
+  955506,
+  213312,
+  0,
+  2,
+  270652,
+  22588,
+  4,
+  1457325,
+  64566,
+  4,
+  20467,
+  1,
+  4,
+  0,
+  141992,
+  32,
+  100788,
+  420,
+  1,
+  1,
+  81663,
+  32,
+  59498,
+  32,
+  20142,
+  32,
+  24588,
+  32,
+  20744,
+  32,
+  25933,
+  32,
+  24623,
+  32,
+  43053543,
+  10,
+  53384111,
+  14333,
+  10,
+  43574283,
+  26308,
+  10
+];
+var DEFAULT_V3_COST_MODEL_LIST = [
+  100788,
+  420,
+  1,
+  1,
+  1e3,
+  173,
+  0,
+  1,
+  1e3,
+  59957,
+  4,
+  1,
+  11183,
+  32,
+  201305,
+  8356,
+  4,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  16e3,
+  100,
+  100,
+  100,
+  16e3,
+  100,
+  94375,
+  32,
+  132994,
+  32,
+  61462,
+  4,
+  72010,
+  178,
+  0,
+  1,
+  22151,
+  32,
+  91189,
+  769,
+  4,
+  2,
+  85848,
+  123203,
+  7305,
+  -900,
+  1716,
+  549,
+  57,
+  85848,
+  0,
+  1,
+  1,
+  1e3,
+  42921,
+  4,
+  2,
+  24548,
+  29498,
+  38,
+  1,
+  898148,
+  27279,
+  1,
+  51775,
+  558,
+  1,
+  39184,
+  1e3,
+  60594,
+  1,
+  141895,
+  32,
+  83150,
+  32,
+  15299,
+  32,
+  76049,
+  1,
+  13169,
+  4,
+  22100,
+  10,
+  28999,
+  74,
+  1,
+  28999,
+  74,
+  1,
+  43285,
+  552,
+  1,
+  44749,
+  541,
+  1,
+  33852,
+  32,
+  68246,
+  32,
+  72362,
+  32,
+  7243,
+  32,
+  7391,
+  32,
+  11546,
+  32,
+  85848,
+  123203,
+  7305,
+  -900,
+  1716,
+  549,
+  57,
+  85848,
+  0,
+  1,
+  90434,
+  519,
+  0,
+  1,
+  74433,
+  32,
+  85848,
+  123203,
+  7305,
+  -900,
+  1716,
+  549,
+  57,
+  85848,
+  0,
+  1,
+  1,
+  85848,
+  123203,
+  7305,
+  -900,
+  1716,
+  549,
+  57,
+  85848,
+  0,
+  1,
+  955506,
+  213312,
+  0,
+  2,
+  270652,
+  22588,
+  4,
+  1457325,
+  64566,
+  4,
+  20467,
+  1,
+  4,
+  0,
+  141992,
+  32,
+  100788,
+  420,
+  1,
+  1,
+  81663,
+  32,
+  59498,
+  32,
+  20142,
+  32,
+  24588,
+  32,
+  20744,
+  32,
+  25933,
+  32,
+  24623,
+  32,
+  43053543,
+  10,
+  53384111,
+  14333,
+  10,
+  43574283,
+  26308,
+  10,
+  16e3,
+  100,
+  16e3,
+  100,
+  962335,
+  18,
+  2780678,
+  6,
+  442008,
+  1,
+  52538055,
+  3756,
+  18,
+  267929,
+  18,
+  76433006,
+  8868,
+  18,
+  52948122,
+  18,
+  1995836,
+  36,
+  3227919,
+  12,
+  901022,
+  1,
+  166917843,
+  4307,
+  36,
+  284546,
+  36,
+  158221314,
+  26549,
+  36,
+  74698472,
+  36,
+  333849714,
+  1,
+  254006273,
+  72,
+  2174038,
+  72,
+  2261318,
+  64571,
+  4,
+  207616,
+  8310,
+  4,
+  1293828,
+  28716,
+  63,
+  0,
+  1,
+  1006041,
+  43623,
+  251,
+  0,
+  1,
+  100181,
+  726,
+  719,
+  0,
+  1,
+  100181,
+  726,
+  719,
+  0,
+  1,
+  100181,
+  726,
+  719,
+  0,
+  1,
+  107878,
+  680,
+  0,
+  1,
+  95336,
+  1,
+  281145,
+  18848,
+  0,
+  1,
+  180194,
+  159,
+  1,
+  1,
+  158519,
+  8942,
+  0,
+  1,
+  159378,
+  8813,
+  0,
+  1,
+  107490,
+  3298,
+  1,
+  106057,
+  655,
+  1,
+  1964219,
+  24520,
+  3
+];
+
+// src/constants/placeholder.ts
+var import_cardano_wasm6 = require("@hydrawallet-sdk/cardano-wasm");
+var PLACEHOLDER_ADDRESS = {
+  [import_cardano_wasm6.CardanoWASM.NetworkInfo.mainnet().network_id()]: "addr1qrsx72hrv8ens90hwkezg7ysyhwvcjmyzdveyf88ppq7a0lwu7gv0wuuf9lhzm7wclvj5ntgcfa53j0rqxmu237x20xspeqa7n",
+  [import_cardano_wasm6.CardanoWASM.NetworkInfo.testnet_preprod().network_id()]: "addr_test1qrsx72hrv8ens90hwkezg7ysyhwvcjmyzdveyf88ppq7a0lwu7gv0wuuf9lhzm7wclvj5ntgcfa53j0rqxmu237x20xsne56q3",
+  [import_cardano_wasm6.CardanoWASM.NetworkInfo.testnet_preview().network_id()]: "addr_test1qruhen60uwzpwnnr7gjs50z2v8u9zyfw6zunet4k42zrpr54mrlv55f93rs6j48wt29w90hlxt4rvpvshe55k5r9mpvqjv2wt4"
+};
+
+// src/constants/protocol-parameters.ts
+var DEFAULT_PROTOCOL_PARAMETERS = {
+  epoch: 0,
+  coinsPerUtxoSize: 4310,
+  priceMem: 0.0577,
+  priceStep: 721e-7,
+  minFeeA: 44,
+  minFeeB: 155381,
+  keyDeposit: 2e6,
+  maxTxSize: 16384,
+  maxValSize: 5e3,
+  poolDeposit: 5e8,
+  maxCollateralInputs: 3,
+  decentralisation: 0,
+  maxBlockSize: 98304,
+  collateralPercent: 150,
+  maxBlockHeaderSize: 1100,
+  minPoolCost: "340000000",
+  maxTxExMem: "16000000",
+  maxTxExSteps: "10000000000",
+  maxBlockExMem: "80000000",
+  maxBlockExSteps: "40000000000",
+  minFeeRefScriptCostPerByte: 15
+};
+var DREP_DEPOSIT = "500000000";
+var resolveTxFees = (txSize, minFeeA = DEFAULT_PROTOCOL_PARAMETERS.minFeeA, minFeeB = DEFAULT_PROTOCOL_PARAMETERS.minFeeB) => {
+  const fees = BigInt(minFeeA) * BigInt(txSize) + BigInt(minFeeB);
+  return fees.toString();
+};
+
+// src/constants/index.ts
+var LANGUAGE_VERSIONS = {
+  V1: "V1",
+  V2: "V2",
+  V3: "V3"
+};
+var HARDENED_KEY_START = 2147483648;
+
+// src/types/cardano/asset.ts
+var mergeAssets = (assets) => {
+  const merged = [];
+  assets.forEach((asset) => {
+    const existing = merged.find((a) => a.unit === asset.unit);
+    if (existing) {
+      existing.quantity = (BigInt(existing.quantity) + BigInt(asset.quantity)).toString();
+    } else {
+      merged.push(asset);
+    }
+  });
+  return merged;
+};
+
+// src/types/cardano/asset-metadata.ts
+var royaltiesStandardKeys = ["rate", "address"];
+var metadataStandardKeys = [
+  "name",
+  "image",
+  "mediaType",
+  "description",
+  "instagram",
+  "twitter",
+  "discord",
+  "website"
+];
+var fungibleAssetKeys = ["ticker", "decimals"];
+var metadataToCip68 = (metadata) => {
+  switch (typeof metadata) {
+    case "object":
+      if (metadata instanceof Array) {
+        return metadata.map((item) => metadataToCip68(item));
+      }
+      const metadataMap = /* @__PURE__ */ new Map();
+      const keys = Object.keys(metadata);
+      keys.forEach((key) => {
+        metadataMap.set(key, metadataToCip68(metadata[key]));
+      });
+      return {
+        alternative: 0,
+        fields: [metadataMap, 1]
+      };
+    default:
+      return metadata;
+  }
+};
+
+// src/types/protocol.ts
+var castProtocol = (data) => {
+  const result = {};
+  for (const rawKey in DEFAULT_PROTOCOL_PARAMETERS) {
+    const key = rawKey;
+    const defaultValue = DEFAULT_PROTOCOL_PARAMETERS[key];
+    const value = data[key];
+    if (typeof defaultValue === "number") {
+      result[key] = !value && value !== 0 ? defaultValue : Number(value);
+    } else if (typeof defaultValue === "string") {
+      result[key] = !value && value !== "" ? defaultValue : value.toString();
+    }
+  }
+  return result;
+};
+
+// src/utils/cardano-wasm/serializer.ts
+var serializeAssetUnit = (policyId, assetName) => {
+  return policyId + assetName;
+};
+
+// src/utils/cardano-wasm/converter.ts
+var import_cardano_wasm7 = require("@hydrawallet-sdk/cardano-wasm");
+var convertUTxOToUTxOObject = (utxos) => {
+  return utxos.reduce((acc, cur) => {
+    acc[`${cur.input.txHash}#${cur.input.outputIndex}`] = {
+      address: cur.output.address,
+      datum: cur.output.datum ? cur.output.datum.to_hex() : null,
+      datumhash: cur.output.datumHash || null,
+      inlineDatum: cur.output.inlineDatum ? cur.output.inlineDatum.to_json(import_cardano_wasm7.CardanoWASM.PlutusDatumSchema.DetailedSchema) : null,
+      inlineDatumRaw: cur.output.inlineDatum ? cur.output.inlineDatum.to_hex() : null,
+      // TODO: update it if using scriptRef
+      referenceScript: null,
+      value: cur.output.amount.reduce(
+        (acc2, cur2) => {
+          if (cur2.unit === "lovelace") {
+            acc2.lovelace = Number(cur2.quantity);
+          } else {
+            const { policyId, assetName } = deserializeAssetUnit(cur2.unit);
+            if (!acc2[policyId]) {
+              acc2[policyId] = {};
+            }
+            acc2[policyId][assetName] = Number(cur2.quantity);
+          }
+          return acc2;
+        },
+        {}
+      )
+    };
+    return acc;
+  }, {});
+};
+var convertUTxOObjectToUTxO = (utxoObject) => {
+  return Object.keys(utxoObject).map((txHash) => {
+    const [txId, txIndex] = txHash.split("#");
+    const outputIndex = Number(txIndex);
+    const utxo = utxoObject[txHash];
+    const amount = [{ unit: "lovelace", quantity: String(utxo.value.lovelace) }];
+    for (const [policyId, assets] of Object.entries(utxo.value)) {
+      for (const [assetName, quantity] of Object.entries(assets)) {
+        amount.push({
+          unit: `${policyId}${assetName}`,
+          quantity: String(quantity)
+        });
+      }
+    }
+    return {
+      input: {
+        outputIndex,
+        txHash: txId
+      },
+      output: {
+        address: utxo.address,
+        amount,
+        datum: void 0,
+        datumHash: utxo.datumhash,
+        inlineDatum: void 0,
+        scriptRef: void 0,
+        scriptHash: void 0
+      }
+    };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppWallet,
+  ChainDerivation,
+  CoinTypes,
+  DEFAULT_PROTOCOL_PARAMETERS,
+  DEFAULT_V1_COST_MODEL_LIST,
+  DEFAULT_V2_COST_MODEL_LIST,
+  DEFAULT_V3_COST_MODEL_LIST,
+  DREP_DEPOSIT,
+  EmbeddedWallet,
+  HARDENED_KEY_START,
+  LANGUAGE_VERSIONS,
+  NETWORK_ID,
+  NETWORK_MAGIC,
+  PLACEHOLDER_ADDRESS,
+  Purpose,
+  WalletStaticMethods,
+  buildBaseAddress,
+  buildDRepID,
+  buildEnterpriseAddress,
+  buildKeys,
+  buildRewardAddress,
+  bytesToHex,
+  castProtocol,
+  clampScalar,
+  convertUTxOObjectToUTxO,
+  convertUTxOToUTxOObject,
+  deserializeAssetUnit,
+  deserializeTx,
+  fromUTF8,
+  fungibleAssetKeys,
+  hexToBytes,
+  hexToString,
+  mergeAssets,
+  metadataStandardKeys,
+  metadataToCip68,
+  resolveTxBodyHash,
+  resolveTxFees,
+  resolveTxHash,
+  royaltiesStandardKeys,
+  serializeAssetUnit,
+  stringToHex,
+  stripExtendedKey,
+  toBytes,
+  toUTF8
+});
+//# sourceMappingURL=index.js.map