@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/chunk-YUPMXTCJ.js

@@ -1,622 +0,0 @@
-import {
-  generateAdaptorFromSignature,
-  getRandomSigningNonce,
-  getSigningCommitmentFromNonce,
-  subtractPrivateKeys
-} from "./chunk-NSJF5F5O.js";
-import {
-  splitSecretWithProofs
-} from "./chunk-QNNSEJ4P.js";
-import {
-  isReactNative
-} from "./chunk-7V6N75CC.js";
-import {
-  ConfigurationError,
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-import {
-  Buffer
-} from "./chunk-MVRQ5US7.js";
-
-// src/signer/signer.ts
-import {
-  bytesToHex,
-  bytesToNumberBE,
-  equalBytes,
-  hexToBytes
-} from "@noble/curves/abstract/utils";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-import { HDKey } from "@scure/bip32";
-import { generateMnemonic, mnemonicToSeed } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english";
-import * as ecies from "eciesjs";
-import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
-import {
-  fromPrivateKey,
-  PARITY,
-  Receipt
-} from "@buildonspark/lrc20-sdk";
-import { sha256 } from "@noble/hashes/sha2";
-import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
-import { Receipt as Receipt2, PARITY as PARITY2, fromPrivateKey as fromPrivateKey2 } from "@buildonspark/lrc20-sdk";
-import { MultisigReceiptInput } from "@buildonspark/lrc20-sdk/lrc/types";
-var sparkFrostModule = void 0;
-var getSparkFrostModule = async () => {
-  if (isReactNative) {
-    return void 0;
-  }
-  if (!sparkFrostModule) {
-    sparkFrostModule = await import("./spark_bindings/wasm/index.js");
-  }
-  return sparkFrostModule;
-};
-var HARDENED_OFFSET = 2147483648;
-var DefaultSparkKeysGenerator = class {
-  async deriveKeysFromSeed(seed, accountNumber) {
-    const hdkey = HDKey.fromMasterSeed(seed);
-    if (!hdkey.privateKey || !hdkey.publicKey) {
-      throw new ValidationError("Failed to derive keys from seed", {
-        field: "hdkey",
-        value: seed
-      });
-    }
-    const identityKey = hdkey.derive(`m/8797555'/${accountNumber}'/0'`);
-    const signingKey = hdkey.derive(`m/8797555'/${accountNumber}'/1'`);
-    const depositKey = hdkey.derive(`m/8797555'/${accountNumber}'/2'`);
-    const staticDepositKey = hdkey.derive(`m/8797555'/${accountNumber}'/3'`);
-    if (!identityKey.privateKey || !depositKey.privateKey || !signingKey.privateKey || !identityKey.publicKey || !depositKey.publicKey || !signingKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
-      throw new ValidationError(
-        "Failed to derive all required keys from seed",
-        {
-          field: "derivedKeys"
-        }
-      );
-    }
-    return {
-      masterPublicKey: hdkey.publicKey,
-      identityKey: {
-        privateKey: identityKey.privateKey,
-        publicKey: identityKey.publicKey
-      },
-      signingHDKey: {
-        hdKey: signingKey,
-        privateKey: signingKey.privateKey,
-        publicKey: signingKey.publicKey
-      },
-      depositKey: {
-        privateKey: depositKey.privateKey,
-        publicKey: depositKey.publicKey
-      },
-      staticDepositHDKey: {
-        hdKey: staticDepositKey,
-        privateKey: staticDepositKey.privateKey,
-        publicKey: staticDepositKey.publicKey
-      }
-    };
-  }
-};
-var TaprootOutputKeysGenerator = class {
-  constructor(useAddressIndex = false) {
-    this.useAddressIndex = useAddressIndex;
-  }
-  async deriveKeysFromSeed(seed, accountNumber) {
-    const hdkey = HDKey.fromMasterSeed(seed);
-    if (!hdkey.privateKey || !hdkey.publicKey) {
-      throw new ValidationError("Failed to derive keys from seed", {
-        field: "hdkey",
-        value: seed
-      });
-    }
-    const derivationPath = this.useAddressIndex ? `m/86'/0'/0'/0/${accountNumber}` : `m/86'/0'/${accountNumber}'/0/0`;
-    const taprootInternalKey = hdkey.derive(derivationPath);
-    let tweakedPrivateKey = taprootTweakPrivKey(taprootInternalKey.privateKey);
-    let tweakedPublicKey = secp256k1.getPublicKey(tweakedPrivateKey);
-    if (tweakedPublicKey[0] === 3) {
-      tweakedPrivateKey = privateNegate(tweakedPrivateKey);
-      tweakedPublicKey = secp256k1.getPublicKey(tweakedPrivateKey);
-    }
-    const identityKey = {
-      publicKey: tweakedPublicKey,
-      privateKey: tweakedPrivateKey
-    };
-    const signingKey = hdkey.derive(`${derivationPath}/1'`);
-    const depositKey = hdkey.derive(`${derivationPath}/2'`);
-    const staticDepositKey = hdkey.derive(`${derivationPath}/3'`);
-    if (!signingKey.privateKey || !signingKey.publicKey || !depositKey.privateKey || !depositKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
-      throw new ValidationError(
-        "Failed to derive all required keys from seed",
-        {
-          field: "derivedKeys"
-        }
-      );
-    }
-    return {
-      masterPublicKey: hdkey.publicKey,
-      identityKey: {
-        privateKey: identityKey.privateKey,
-        publicKey: identityKey.publicKey
-      },
-      signingHDKey: {
-        hdKey: signingKey,
-        privateKey: signingKey.privateKey,
-        publicKey: signingKey.publicKey
-      },
-      depositKey: {
-        privateKey: depositKey.privateKey,
-        publicKey: depositKey.publicKey
-      },
-      staticDepositHDKey: {
-        hdKey: staticDepositKey,
-        privateKey: staticDepositKey.privateKey,
-        publicKey: staticDepositKey.publicKey
-      }
-    };
-  }
-};
-var DefaultSparkSigner = class {
-  masterPublicKey = null;
-  identityKey = null;
-  signingKey = null;
-  depositKey = null;
-  staticDepositKey = null;
-  staticDepositKeyMap = /* @__PURE__ */ new Map();
-  // <hex, hex>
-  publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
-  commitmentToNonceMap = /* @__PURE__ */ new Map();
-  keysGenerator;
-  constructor({
-    sparkKeysGenerator
-  } = {}) {
-    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
-  }
-  deriveSigningKey(hash) {
-    if (!this.signingKey) {
-      throw new ValidationError("Private key not initialized", {
-        field: "signingKey"
-      });
-    }
-    const view = new DataView(hash.buffer);
-    const amount = view.getUint32(0, false) % HARDENED_OFFSET + HARDENED_OFFSET;
-    const newPrivateKey = this.signingKey?.deriveChild(amount).privateKey;
-    if (!newPrivateKey) {
-      throw new ValidationError("Failed to recover signing key", {
-        field: "privateKey"
-      });
-    }
-    return newPrivateKey;
-  }
-  async restoreSigningKeysFromLeafs(leafs) {
-    if (!this.signingKey) {
-      throw new ValidationError("Signing key is not set", {
-        field: "signingKey"
-      });
-    }
-    for (const leaf of leafs) {
-      const hash = sha256(leaf.id);
-      const privateKey = this.deriveSigningKey(hash);
-      const publicKey = secp256k1.getPublicKey(privateKey);
-      this.publicKeyToPrivateKeyMap.set(
-        bytesToHex(publicKey),
-        bytesToHex(privateKey)
-      );
-    }
-  }
-  async getSchnorrPublicKey(publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
-    if (!privateKey) {
-      throw new ValidationError("Private key is not set", {
-        field: "privateKey"
-      });
-    }
-    return schnorr.getPublicKey(hexToBytes(privateKey));
-  }
-  async signSchnorr(message, publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
-    if (!privateKey) {
-      throw new ValidationError("Private key is not set", {
-        field: "privateKey"
-      });
-    }
-    return schnorr.sign(message, hexToBytes(privateKey));
-  }
-  async signSchnorrWithIdentityKey(message) {
-    if (!this.identityKey?.privateKey) {
-      throw new ValidationError("Private key not set", {
-        field: "identityKey"
-      });
-    }
-    const signature = schnorr.sign(message, this.identityKey.privateKey);
-    return signature;
-  }
-  async getIdentityPublicKey() {
-    if (!this.identityKey?.publicKey) {
-      throw new ValidationError("Private key is not set", {
-        field: "identityKey"
-      });
-    }
-    return this.identityKey.publicKey;
-  }
-  async getDepositSigningKey() {
-    if (!this.depositKey?.publicKey) {
-      throw new ValidationError("Deposit key is not set", {
-        field: "depositKey"
-      });
-    }
-    return this.depositKey.publicKey;
-  }
-  async generateStaticDepositKey(idx) {
-    if (!this.staticDepositKey?.privateKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    if (this.staticDepositKeyMap.has(idx)) {
-      const staticDepositKey2 = this.staticDepositKeyMap.get(idx);
-      return staticDepositKey2?.publicKey;
-    }
-    const staticDepositKey = this.staticDepositKey.deriveChild(
-      HARDENED_OFFSET + idx
-    );
-    this.staticDepositKeyMap.set(idx, staticDepositKey);
-    this.publicKeyToPrivateKeyMap.set(
-      bytesToHex(staticDepositKey.publicKey),
-      bytesToHex(staticDepositKey.privateKey)
-    );
-    return staticDepositKey.publicKey;
-  }
-  async getStaticDepositSigningKey(idx) {
-    if (!this.staticDepositKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    if (!this.staticDepositKeyMap.has(idx)) {
-      await this.generateStaticDepositKey(idx);
-    }
-    const staticDepositKey = this.staticDepositKeyMap.get(idx);
-    if (!staticDepositKey?.publicKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    return staticDepositKey.publicKey;
-  }
-  async getStaticDepositSecretKey(idx) {
-    if (!this.staticDepositKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    if (!this.staticDepositKeyMap.has(idx)) {
-      await this.generateStaticDepositKey(idx);
-    }
-    const staticDepositKey = this.staticDepositKeyMap.get(idx);
-    if (!staticDepositKey?.privateKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    return staticDepositKey.privateKey;
-  }
-  async generateMnemonic() {
-    return generateMnemonic(wordlist);
-  }
-  async mnemonicToSeed(mnemonic) {
-    return await mnemonicToSeed(mnemonic);
-  }
-  async getTrackedPublicKeys() {
-    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(hexToBytes);
-  }
-  async generatePublicKey(hash) {
-    if (!this.signingKey) {
-      throw new ValidationError("Private key is not set", {
-        field: "signingKey"
-      });
-    }
-    let newPrivateKey = null;
-    if (hash) {
-      newPrivateKey = this.deriveSigningKey(hash);
-    } else {
-      newPrivateKey = secp256k1.utils.randomPrivateKey();
-    }
-    if (!newPrivateKey) {
-      throw new ValidationError("Failed to generate new private key", {
-        field: "privateKey"
-      });
-    }
-    const publicKey = secp256k1.getPublicKey(newPrivateKey);
-    const pubKeyHex = bytesToHex(publicKey);
-    const privKeyHex = bytesToHex(newPrivateKey);
-    this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
-    return publicKey;
-  }
-  async removePublicKey(publicKey) {
-    this.publicKeyToPrivateKeyMap.delete(bytesToHex(publicKey));
-  }
-  async subtractPrivateKeysGivenPublicKeys(first, second) {
-    const firstPubKeyHex = bytesToHex(first);
-    const secondPubKeyHex = bytesToHex(second);
-    const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
-    const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
-    if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
-      throw new Error("Private key is not set");
-    }
-    const firstPrivateKey = hexToBytes(firstPrivateKeyHex);
-    const secondPrivateKey = hexToBytes(secondPrivateKeyHex);
-    const resultPrivKey = subtractPrivateKeys(
-      firstPrivateKey,
-      secondPrivateKey
-    );
-    const resultPubKey = secp256k1.getPublicKey(resultPrivKey);
-    const resultPrivKeyHex = bytesToHex(resultPrivKey);
-    const resultPubKeyHex = bytesToHex(resultPubKey);
-    this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
-    return resultPubKey;
-  }
-  async splitSecretWithProofs({
-    secret,
-    curveOrder,
-    threshold,
-    numShares,
-    isSecretPubkey = false
-  }) {
-    if (isSecretPubkey) {
-      const pubKeyHex = bytesToHex(secret);
-      const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
-      if (!privateKey) {
-        throw new Error("Private key is not set");
-      }
-      secret = hexToBytes(privateKey);
-    }
-    const secretAsInt = bytesToNumberBE(secret);
-    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
-  }
-  async signFrost({
-    message,
-    privateAsPubKey,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey
-  }) {
-    const SparkFrost = await getSparkFrostModule();
-    if (!SparkFrost) {
-      throw new ValidationError("SparkFrost module not found", {
-        field: "SparkFrost"
-      });
-    }
-    const privateAsPubKeyHex = bytesToHex(privateAsPubKey);
-    const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
-    if (!signingPrivateKey) {
-      throw new ValidationError("Private key not found for public key", {
-        field: "privateKey"
-      });
-    }
-    const nonce = this.commitmentToNonceMap.get(selfCommitment);
-    if (!nonce) {
-      throw new ValidationError("Nonce not found for commitment", {
-        field: "nonce"
-      });
-    }
-    const keyPackage = {
-      secretKey: hexToBytes(signingPrivateKey),
-      publicKey,
-      verifyingKey
-    };
-    return SparkFrost.signFrost({
-      message,
-      keyPackage,
-      nonce,
-      selfCommitment,
-      statechainCommitments,
-      adaptorPubKey
-    });
-  }
-  async aggregateFrost({
-    message,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey,
-    selfSignature,
-    statechainSignatures,
-    statechainPublicKeys
-  }) {
-    const SparkFrost = await getSparkFrostModule();
-    if (!SparkFrost) {
-      throw new ValidationError("SparkFrost module not found", {
-        field: "SparkFrost"
-      });
-    }
-    return SparkFrost.aggregateFrost({
-      message,
-      statechainSignatures,
-      statechainPublicKeys,
-      verifyingKey,
-      statechainCommitments,
-      selfCommitment,
-      selfPublicKey: publicKey,
-      selfSignature,
-      adaptorPubKey
-    });
-  }
-  async createSparkWalletFromSeed(seed, accountNumber) {
-    if (typeof seed === "string") {
-      seed = hexToBytes(seed);
-    }
-    const {
-      masterPublicKey,
-      identityKey,
-      signingHDKey: signingKey,
-      depositKey,
-      staticDepositHDKey: staticDepositKey
-    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
-    this.masterPublicKey = masterPublicKey;
-    this.identityKey = identityKey;
-    this.depositKey = depositKey;
-    this.signingKey = signingKey.hdKey;
-    this.staticDepositKey = staticDepositKey.hdKey;
-    this.publicKeyToPrivateKeyMap.set(
-      bytesToHex(identityKey.publicKey),
-      bytesToHex(identityKey.privateKey)
-    );
-    this.publicKeyToPrivateKeyMap.set(
-      bytesToHex(depositKey.publicKey),
-      bytesToHex(depositKey.privateKey)
-    );
-    this.publicKeyToPrivateKeyMap.set(
-      bytesToHex(staticDepositKey.publicKey),
-      bytesToHex(staticDepositKey.privateKey)
-    );
-    return bytesToHex(identityKey.publicKey);
-  }
-  async signMessageWithPublicKey(message, publicKey, compact) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
-    if (!privateKey) {
-      throw new ValidationError("Private key not found for public key", {
-        field: "privateKey",
-        value: bytesToHex(publicKey)
-      });
-    }
-    const signature = secp256k1.sign(message, hexToBytes(privateKey));
-    if (compact) {
-      return signature.toCompactRawBytes();
-    }
-    return signature.toDERRawBytes();
-  }
-  async signMessageWithIdentityKey(message, compact) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    const signature = secp256k1.sign(message, this.identityKey.privateKey);
-    if (compact) {
-      return signature.toCompactRawBytes();
-    }
-    return signature.toDERRawBytes();
-  }
-  async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
-    const publicKeyHex = bytesToHex(publicKey);
-    const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
-    if (!privateKey) {
-      throw new Error("Private key is not set");
-    }
-    return ecies.encrypt(receiverPublicKey, hexToBytes(privateKey));
-  }
-  async decryptEcies(ciphertext) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      bytesToHex(this.identityKey.privateKey)
-    );
-    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
-    const publicKey = secp256k1.getPublicKey(privateKey);
-    const publicKeyHex = bytesToHex(publicKey);
-    const privateKeyHex = bytesToHex(privateKey);
-    this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
-    return publicKey;
-  }
-  async getRandomSigningCommitment() {
-    const nonce = getRandomSigningNonce();
-    const commitment = getSigningCommitmentFromNonce(nonce);
-    this.commitmentToNonceMap.set(commitment, nonce);
-    return commitment;
-  }
-  async hashRandomPrivateKey() {
-    return sha256(secp256k1.utils.randomPrivateKey());
-  }
-  async generateAdaptorFromSignature(signature) {
-    const adaptor = generateAdaptorFromSignature(signature);
-    const adaptorPublicKey = secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
-    this.publicKeyToPrivateKeyMap.set(
-      bytesToHex(adaptorPublicKey),
-      bytesToHex(adaptor.adaptorPrivateKey)
-    );
-    return {
-      adaptorSignature: signature,
-      adaptorPublicKey
-    };
-  }
-  async getMasterPublicKey() {
-    if (!this.masterPublicKey) {
-      throw new Error("Private key is not set");
-    }
-    return this.masterPublicKey;
-  }
-  async validateMessageWithIdentityKey(message, signature) {
-    if (!this.identityKey?.publicKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    return secp256k1.verify(signature, message, this.identityKey.publicKey);
-  }
-  async signPsbt(psbt, input, sighashTypes, receipt) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    if (receipt) {
-      const receiptPrivateKey = this.getReceiptPrivateKey(receipt);
-      const tweakedKeyPair = fromPrivateKey(Buffer.from(receiptPrivateKey));
-      psbt.signInput(input, tweakedKeyPair, sighashTypes);
-      return psbt;
-    }
-    const keypair = fromPrivateKey(Buffer.from(this.identityKey.privateKey));
-    psbt.signInput(input, keypair, sighashTypes);
-    return psbt;
-  }
-  getReceiptPrivateKey(receipt) {
-    const pxh = Receipt.receiptHash(receipt);
-    let innerKey = this.identityKey.publicKey;
-    let privateKey = this.identityKey.privateKey;
-    if (innerKey[0] === 3) {
-      innerKey = Buffer.concat([PARITY, innerKey.slice(1)]);
-      privateKey = Buffer.from(privateNegate(privateKey));
-    }
-    const pxhPubkey = sha256(Buffer.concat([pxh, innerKey]));
-    const receiptProof = privateAdd(privateKey, pxhPubkey);
-    return Buffer.from(receiptProof);
-  }
-  signTransactionIndex(tx, index, publicKey) {
-    let privateKey;
-    if (equalBytes(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
-      privateKey = this.identityKey?.privateKey;
-    } else if (equalBytes(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
-      privateKey = this.depositKey?.privateKey;
-    } else {
-      privateKey = hexToBytes(
-        this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey)) ?? ""
-      );
-    }
-    if (!privateKey) {
-      throw new ValidationError("Private key not found for public key", {
-        field: "privateKey",
-        value: bytesToHex(publicKey)
-      });
-    }
-    tx.signIdx(privateKey, index);
-  }
-};
-var TaprootSparkSigner = class extends DefaultSparkSigner {
-  constructor() {
-    super({ sparkKeysGenerator: new TaprootOutputKeysGenerator() });
-  }
-};
-
-export {
-  TaprootOutputKeysGenerator,
-  DefaultSparkSigner,
-  TaprootSparkSigner,
-  Receipt2 as Receipt,
-  PARITY2 as PARITY,
-  fromPrivateKey2 as fromPrivateKey,
-  MultisigReceiptInput
-};

package/dist/chunk-Z5HIAYFT.js

@@ -1,84 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-
-// src/utils/network.ts
-import { NetworkType as Lrc20NetworkType } from "@buildonspark/lrc20-sdk";
-import * as btc from "@scure/btc-signer";
-import * as bitcoin from "bitcoinjs-lib";
-var Network2 = /* @__PURE__ */ ((Network3) => {
-  Network3[Network3["MAINNET"] = 0] = "MAINNET";
-  Network3[Network3["TESTNET"] = 1] = "TESTNET";
-  Network3[Network3["SIGNET"] = 2] = "SIGNET";
-  Network3[Network3["REGTEST"] = 3] = "REGTEST";
-  Network3[Network3["LOCAL"] = 4] = "LOCAL";
-  return Network3;
-})(Network2 || {});
-var NetworkToProto = {
-  [0 /* MAINNET */]: 1 /* MAINNET */,
-  [1 /* TESTNET */]: 3 /* TESTNET */,
-  [2 /* SIGNET */]: 4 /* SIGNET */,
-  [3 /* REGTEST */]: 2 /* REGTEST */,
-  [4 /* LOCAL */]: 2 /* REGTEST */
-};
-var NetworkConfig = {
-  [0 /* MAINNET */]: btc.NETWORK,
-  [1 /* TESTNET */]: btc.TEST_NETWORK,
-  [2 /* SIGNET */]: btc.TEST_NETWORK,
-  [3 /* REGTEST */]: { ...btc.TEST_NETWORK, bech32: "bcrt" },
-  [4 /* LOCAL */]: { ...btc.TEST_NETWORK, bech32: "bcrt" }
-};
-var getNetwork = (network) => NetworkConfig[network];
-var LRC_WALLET_NETWORK = Object.freeze({
-  [0 /* MAINNET */]: bitcoin.networks.bitcoin,
-  [1 /* TESTNET */]: bitcoin.networks.testnet,
-  [2 /* SIGNET */]: bitcoin.networks.testnet,
-  [3 /* REGTEST */]: bitcoin.networks.regtest,
-  [4 /* LOCAL */]: bitcoin.networks.regtest
-});
-var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [0 /* MAINNET */]: Lrc20NetworkType.MAINNET,
-  [1 /* TESTNET */]: Lrc20NetworkType.TESTNET,
-  [2 /* SIGNET */]: Lrc20NetworkType.TESTNET,
-  [3 /* REGTEST */]: Lrc20NetworkType.REGTEST,
-  [4 /* LOCAL */]: Lrc20NetworkType.LOCAL
-});
-function getNetworkFromAddress(address2) {
-  try {
-    const decoded = bitcoin.address.fromBech32(address2);
-    if (decoded.prefix === "bc") {
-      return "MAINNET" /* MAINNET */;
-    } else if (decoded.prefix === "bcrt") {
-      return "REGTEST" /* REGTEST */;
-    }
-  } catch (err) {
-    throw new ValidationError(
-      "Invalid Bitcoin address",
-      {
-        field: "address",
-        value: address2,
-        expected: "Valid Bech32 address with prefix 'bc' or 'bcrt'"
-      },
-      err instanceof Error ? err : void 0
-    );
-  }
-  return null;
-}
-function getNetworkFromString(network) {
-  const net = (network ?? "REGTEST").toUpperCase();
-  if (net === "MAINNET") return 0 /* MAINNET */;
-  if (net === "TESTNET") return 1 /* TESTNET */;
-  if (net === "SIGNET") return 2 /* SIGNET */;
-  if (net === "LOCAL") return 4 /* LOCAL */;
-  return 3 /* REGTEST */;
-}
-
-export {
-  Network2 as Network,
-  NetworkToProto,
-  getNetwork,
-  LRC_WALLET_NETWORK,
-  LRC_WALLET_NETWORK_TYPE,
-  getNetworkFromAddress,
-  getNetworkFromString
-};