@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/libs/modules/address/networks/btc/get-taproot-address.js

@@ -0,0 +1,458 @@
+import { A as taggedHash, C as concat, d as compare, D as encodingLength, E as encode, F as isTapleaf, a as parse, b as bitcoin, c as prop, O as OPS$1, e as decompile, s as stacksEqual, T as TAPLEAF_VERSION_MASK, v as value, g as partial, o as object, G as number, B as BufferSchema, j as array, q as custom, I as isTaptree, J as union, N as NBufferSchemaFactory, k as string, t as distExports, l as compile } from '../../../../../prefix-config.type-BP_PoMwo.js';
+import '../../../../../index-DiZOBxXK.js';
+import { g as getEccLib } from '../../../../../ecc-CVvMF8il.js';
+import '../../../../../browser-D9H9snNo.js';
+import { AddressError } from '../../libs/exceptions/address-error.exception.js';
+import { ExceptionMessage } from '../../libs/enums/exception-message.enum.js';
+import '../../../../../bip32-CTos7K79.js';
+import '../../../../../index-Bsx2kz1h.js';
+import { convertHexToBytes } from '../../../../utils/convert-hex-to-bytes/convert-hex-to-bytes.util.js';
+import '../../../../../index-CjeBPB5t.js';
+
+const LEAF_VERSION_TAPSCRIPT = 0xc0;
+const isHashBranch = ht => 'left' in ht && 'right' in ht;
+/**
+ * Calculates the root hash from a given control block and leaf hash.
+ * @param controlBlock - The control block buffer.
+ * @param leafHash - The leaf hash buffer.
+ * @returns The root hash buffer.
+ * @throws {TypeError} If the control block length is less than 33.
+ */
+function rootHashFromPath(controlBlock, leafHash) {
+  if (controlBlock.length < 33)
+    throw new TypeError(
+      `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
+    );
+  const m = (controlBlock.length - 33) / 32;
+  let kj = leafHash;
+  for (let j = 0; j < m; j++) {
+    const ej = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
+    if (compare(kj, ej) < 0) {
+      kj = tapBranchHash(kj, ej);
+    } else {
+      kj = tapBranchHash(ej, kj);
+    }
+  }
+  return kj;
+}
+/**
+ * Build a hash tree of merkle nodes from the scripts binary tree.
+ * @param scriptTree - the tree of scripts to pairwise hash.
+ */
+function toHashTree(scriptTree) {
+  if (isTapleaf(scriptTree)) return { hash: tapleafHash(scriptTree) };
+  const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+  // hashes.sort((a, b) => a.hash.compare(b.hash));
+  hashes.sort((a, b) => compare(a.hash, b.hash));
+  const [left, right] = hashes;
+  return {
+    hash: tapBranchHash(left.hash, right.hash),
+    left,
+    right,
+  };
+}
+/**
+ * Given a HashTree, finds the path from a particular hash to the root.
+ * @param node - the root of the tree
+ * @param hash - the hash to search for
+ * @returns - array of sibling hashes, from leaf (inclusive) to root
+ * (exclusive) needed to prove inclusion of the specified hash. undefined if no
+ * path is found
+ */
+function findScriptPath(node, hash) {
+  if (isHashBranch(node)) {
+    const leftPath = findScriptPath(node.left, hash);
+    if (leftPath !== undefined) return [...leftPath, node.right.hash];
+    const rightPath = findScriptPath(node.right, hash);
+    if (rightPath !== undefined) return [...rightPath, node.left.hash];
+  } else if (compare(node.hash, hash) === 0) {
+    return [];
+  }
+  return undefined;
+}
+/**
+ * Calculates the tapleaf hash for a given Tapleaf object.
+ * @param leaf - The Tapleaf object to calculate the hash for.
+ * @returns The tapleaf hash as a Buffer.
+ */
+function tapleafHash(leaf) {
+  const version = leaf.version || LEAF_VERSION_TAPSCRIPT;
+  return taggedHash(
+    'TapLeaf',
+    concat([Uint8Array.from([version]), serializeScript(leaf.output)]),
+  );
+}
+/**
+ * Computes the taproot tweak hash for a given public key and optional hash.
+ * If a hash is provided, the public key and hash are concatenated before computing the hash.
+ * If no hash is provided, only the public key is used to compute the hash.
+ *
+ * @param pubKey - The public key buffer.
+ * @param h - The optional hash buffer.
+ * @returns The taproot tweak hash.
+ */
+function tapTweakHash(pubKey, h) {
+  return taggedHash(
+    'TapTweak',
+    concat(h ? [pubKey, h] : [pubKey]),
+  );
+}
+/**
+ * Tweak a public key with a given tweak hash.
+ * @param pubKey - The public key to be tweaked.
+ * @param h - The tweak hash.
+ * @returns The tweaked public key or null if the input is invalid.
+ */
+function tweakKey(pubKey, h) {
+  if (!(pubKey instanceof Uint8Array)) return null;
+  if (pubKey.length !== 32) return null;
+  if (h && h.length !== 32) return null;
+  const tweakHash = tapTweakHash(pubKey, h);
+  const res = getEccLib().xOnlyPointAddTweak(pubKey, tweakHash);
+  if (!res || res.xOnlyPubkey === null) return null;
+  return {
+    parity: res.parity,
+    x: Uint8Array.from(res.xOnlyPubkey),
+  };
+}
+/**
+ * Computes the TapBranch hash by concatenating two buffers and applying the 'TapBranch' tagged hash algorithm.
+ *
+ * @param a - The first buffer.
+ * @param b - The second buffer.
+ * @returns The TapBranch hash of the concatenated buffers.
+ */
+function tapBranchHash(a, b) {
+  return taggedHash('TapBranch', concat([a, b]));
+}
+/**
+ * Serializes a script by encoding its length as a varint and concatenating it with the script.
+ *
+ * @param s - The script to be serialized.
+ * @returns The serialized script as a Buffer.
+ */
+function serializeScript(s) {
+  /* global BigInt */
+  const varintLen = encodingLength(s.length);
+  const buffer = new Uint8Array(varintLen);
+  encode(s.length, buffer);
+  return concat([buffer, s]);
+}
+
+const OPS = OPS$1;
+const TAPROOT_WITNESS_VERSION = 0x01;
+const ANNEX_PREFIX = 0x50;
+/**
+ * Creates a Pay-to-Taproot (P2TR) payment object.
+ *
+ * @param a - The payment object containing the necessary data for P2TR.
+ * @param opts - Optional payment options.
+ * @returns The P2TR payment object.
+ * @throws {TypeError} If the provided data is invalid or insufficient.
+ */
+function p2tr(a, opts) {
+  if (
+    !a.address &&
+    !a.output &&
+    !a.pubkey &&
+    !a.internalPubkey &&
+    !(a.witness && a.witness.length > 1)
+  )
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  parse(
+    partial(
+      object({
+        address: string(),
+        input: NBufferSchemaFactory(0),
+        network: object({}),
+        output: NBufferSchemaFactory(34),
+        internalPubkey: NBufferSchemaFactory(32),
+        hash: NBufferSchemaFactory(32), // merkle root hash, the tweak
+        pubkey: NBufferSchemaFactory(32), // tweaked with `hash` from `internalPubkey`
+        signature: union([
+          NBufferSchemaFactory(64),
+          NBufferSchemaFactory(65),
+        ]),
+        witness: array(BufferSchema),
+        scriptTree: custom(isTaptree, 'Taptree is not of type isTaptree'),
+        redeem: partial(
+          object({
+            output: BufferSchema, // tapleaf script
+            redeemVersion: number(), // tapleaf version
+            witness: array(BufferSchema),
+          }),
+        ),
+        redeemVersion: number(),
+      }),
+    ),
+    a,
+  );
+  const _address = value(() => {
+    return fromBech32(a.address);
+  });
+  // remove annex if present, ignored by taproot
+  const _witness = value(() => {
+    if (!a.witness || !a.witness.length) return;
+    if (
+      a.witness.length >= 2 &&
+      a.witness[a.witness.length - 1][0] === ANNEX_PREFIX
+    ) {
+      return a.witness.slice(0, -1);
+    }
+    return a.witness.slice();
+  });
+  const _hashTree = value(() => {
+    if (a.scriptTree) return toHashTree(a.scriptTree);
+    if (a.hash) return { hash: a.hash };
+    return;
+  });
+  const network = a.network || bitcoin;
+  const o = { name: 'p2tr', network };
+  prop(o, 'address', () => {
+    if (!o.pubkey) return;
+    const words = distExports.bech32m.toWords(o.pubkey);
+    words.unshift(TAPROOT_WITNESS_VERSION);
+    return distExports.bech32m.encode(network.bech32, words);
+  });
+  prop(o, 'hash', () => {
+    const hashTree = _hashTree();
+    if (hashTree) return hashTree.hash;
+    const w = _witness();
+    if (w && w.length > 1) {
+      const controlBlock = w[w.length - 1];
+      const leafVersion = controlBlock[0] & TAPLEAF_VERSION_MASK;
+      const script = w[w.length - 2];
+      const leafHash = tapleafHash({ output: script, version: leafVersion });
+      return rootHashFromPath(controlBlock, leafHash);
+    }
+    return null;
+  });
+  prop(o, 'output', () => {
+    if (!o.pubkey) return;
+    return compile([OPS.OP_1, o.pubkey]);
+  });
+  prop(o, 'redeemVersion', () => {
+    if (a.redeemVersion) return a.redeemVersion;
+    if (
+      a.redeem &&
+      a.redeem.redeemVersion !== undefined &&
+      a.redeem.redeemVersion !== null
+    ) {
+      return a.redeem.redeemVersion;
+    }
+    return LEAF_VERSION_TAPSCRIPT;
+  });
+  prop(o, 'redeem', () => {
+    const witness = _witness(); // witness without annex
+    if (!witness || witness.length < 2) return;
+    return {
+      output: witness[witness.length - 2],
+      witness: witness.slice(0, -2),
+      redeemVersion: witness[witness.length - 1][0] & TAPLEAF_VERSION_MASK,
+    };
+  });
+  prop(o, 'pubkey', () => {
+    if (a.pubkey) return a.pubkey;
+    if (a.output) return a.output.slice(2);
+    if (a.address) return _address().data;
+    if (o.internalPubkey) {
+      const tweakedKey = tweakKey(o.internalPubkey, o.hash);
+      if (tweakedKey) return tweakedKey.x;
+    }
+  });
+  prop(o, 'internalPubkey', () => {
+    if (a.internalPubkey) return a.internalPubkey;
+    const witness = _witness();
+    if (witness && witness.length > 1)
+      return witness[witness.length - 1].slice(1, 33);
+  });
+  prop(o, 'signature', () => {
+    if (a.signature) return a.signature;
+    const witness = _witness(); // witness without annex
+    if (!witness || witness.length !== 1) return;
+    return witness[0];
+  });
+  prop(o, 'witness', () => {
+    if (a.witness) return a.witness;
+    const hashTree = _hashTree();
+    if (hashTree && a.redeem && a.redeem.output && a.internalPubkey) {
+      const leafHash = tapleafHash({
+        output: a.redeem.output,
+        version: o.redeemVersion,
+      });
+      const path = findScriptPath(hashTree, leafHash);
+      if (!path) return;
+      const outputKey = tweakKey(a.internalPubkey, hashTree.hash);
+      if (!outputKey) return;
+      const controlBock = concat(
+        [
+          Uint8Array.from([o.redeemVersion | outputKey.parity]),
+          a.internalPubkey,
+        ].concat(path),
+      );
+      return [a.redeem.output, controlBock];
+    }
+    if (a.signature) return [a.signature];
+  });
+  // extended validation
+  if (opts.validate) {
+    let pubkey = Uint8Array.from([]);
+    if (a.address) {
+      if (network && network.bech32 !== _address().prefix)
+        throw new TypeError('Invalid prefix or Network mismatch');
+      if (_address().version !== TAPROOT_WITNESS_VERSION)
+        throw new TypeError('Invalid address version');
+      if (_address().data.length !== 32)
+        throw new TypeError('Invalid address data');
+      pubkey = _address().data;
+    }
+    if (a.pubkey) {
+      if (pubkey.length > 0 && compare(pubkey, a.pubkey) !== 0)
+        throw new TypeError('Pubkey mismatch');
+      else pubkey = a.pubkey;
+    }
+    if (a.output) {
+      if (
+        a.output.length !== 34 ||
+        a.output[0] !== OPS.OP_1 ||
+        a.output[1] !== 0x20
+      )
+        throw new TypeError('Output is invalid');
+      if (pubkey.length > 0 && compare(pubkey, a.output.slice(2)) !== 0)
+        throw new TypeError('Pubkey mismatch');
+      else pubkey = a.output.slice(2);
+    }
+    if (a.internalPubkey) {
+      const tweakedKey = tweakKey(a.internalPubkey, o.hash);
+      if (pubkey.length > 0 && compare(pubkey, tweakedKey.x) !== 0)
+        throw new TypeError('Pubkey mismatch');
+      else pubkey = tweakedKey.x;
+    }
+    if (pubkey && pubkey.length) {
+      if (!getEccLib().isXOnlyPoint(pubkey))
+        throw new TypeError('Invalid pubkey for p2tr');
+    }
+    const hashTree = _hashTree();
+    if (a.hash && hashTree) {
+      if (compare(a.hash, hashTree.hash) !== 0)
+        throw new TypeError('Hash mismatch');
+    }
+    if (a.redeem && a.redeem.output && hashTree) {
+      const leafHash = tapleafHash({
+        output: a.redeem.output,
+        version: o.redeemVersion,
+      });
+      if (!findScriptPath(hashTree, leafHash))
+        throw new TypeError('Redeem script not in tree');
+    }
+    const witness = _witness();
+    // compare the provided redeem data with the one computed from witness
+    if (a.redeem && o.redeem) {
+      if (a.redeem.redeemVersion) {
+        if (a.redeem.redeemVersion !== o.redeem.redeemVersion)
+          throw new TypeError('Redeem.redeemVersion and witness mismatch');
+      }
+      if (a.redeem.output) {
+        if (decompile(a.redeem.output).length === 0)
+          throw new TypeError('Redeem.output is invalid');
+        // output redeem is constructed from the witness
+        if (
+          o.redeem.output &&
+          compare(a.redeem.output, o.redeem.output) !== 0
+        )
+          throw new TypeError('Redeem.output and witness mismatch');
+      }
+      if (a.redeem.witness) {
+        if (
+          o.redeem.witness &&
+          !stacksEqual(a.redeem.witness, o.redeem.witness)
+        )
+          throw new TypeError('Redeem.witness and witness mismatch');
+      }
+    }
+    if (witness && witness.length) {
+      if (witness.length === 1) {
+        // key spending
+        if (a.signature && compare(a.signature, witness[0]) !== 0)
+          throw new TypeError('Signature mismatch');
+      } else {
+        // script path spending
+        const controlBlock = witness[witness.length - 1];
+        if (controlBlock.length < 33)
+          throw new TypeError(
+            `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
+          );
+        if ((controlBlock.length - 33) % 32 !== 0)
+          throw new TypeError(
+            `The control-block length of ${controlBlock.length} is incorrect!`,
+          );
+        const m = (controlBlock.length - 33) / 32;
+        if (m > 128)
+          throw new TypeError(
+            `The script path is too long. Got ${m}, expected max 128.`,
+          );
+        const internalPubkey = controlBlock.slice(1, 33);
+        if (
+          a.internalPubkey &&
+          compare(a.internalPubkey, internalPubkey) !== 0
+        )
+          throw new TypeError('Internal pubkey mismatch');
+        if (!getEccLib().isXOnlyPoint(internalPubkey))
+          throw new TypeError('Invalid internalPubkey for p2tr witness');
+        const leafVersion = controlBlock[0] & TAPLEAF_VERSION_MASK;
+        const script = witness[witness.length - 2];
+        const leafHash = tapleafHash({ output: script, version: leafVersion });
+        const hash = rootHashFromPath(controlBlock, leafHash);
+        const outputKey = tweakKey(internalPubkey, hash);
+        if (!outputKey)
+          // todo: needs test data
+          throw new TypeError('Invalid outputKey for p2tr witness');
+        if (pubkey.length && compare(pubkey, outputKey.x) !== 0)
+          throw new TypeError('Pubkey mismatch for p2tr witness');
+        if (outputKey.parity !== (controlBlock[0] & 1))
+          throw new Error('Incorrect parity');
+      }
+    }
+  }
+  return Object.assign(o, a);
+}
+
+/**
+ * Converts a Bech32 or Bech32m encoded address to its corresponding data representation.
+ * @param address - The Bech32 or Bech32m encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32(address) {
+  let result;
+  let version;
+  try {
+    result = distExports.bech32.decode(address);
+  } catch (e) {}
+  if (result) {
+    version = result.words[0];
+    if (version !== 0) throw new TypeError(address + ' uses wrong encoding');
+  } else {
+    result = distExports.bech32m.decode(address);
+    version = result.words[0];
+    if (version === 0) throw new TypeError(address + ' uses wrong encoding');
+  }
+  const data = distExports.bech32.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data),
+  };
+}
+
+function getTaprootAddress(publicKey, prefixConfig) {
+  const publicKeyBytes = convertHexToBytes(publicKey);
+  const { address } = p2tr({ internalPubkey: publicKeyBytes, network: prefixConfig });
+  if (!address) {
+    throw new AddressError(ExceptionMessage.ADDRESS_GENERATION_FAILED);
+  }
+  return address;
+}
+
+export { getTaprootAddress };

package/build/browser/libs/modules/address/networks/btc/index.d.ts

@@ -0,0 +1,6 @@
+export { getBtcSegWitAddress } from '../common/get-btc-seg-wit-address.js';
+export { getBtcNativeSegWitAddress } from '../common/get-btc-native-seg-wit-address.js';
+export { getTaprootAddress } from './get-taproot-address.js';
+export { getP2wshAddress } from './get-p2wsh-address.js';
+export { getP2wshInP2shAddress } from './get-p2wsh-in-p2sh-address.js';
+//# sourceMappingURL=index.d.ts.map

package/build/browser/libs/modules/address/networks/btc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/btc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC"}

package/build/browser/libs/modules/address/networks/btc/index.js

@@ -0,0 +1,5 @@
+export { getBtcSegWitAddress } from '../common/get-btc-seg-wit-address.js';
+export { getBtcNativeSegWitAddress } from '../common/get-btc-native-seg-wit-address.js';
+export { getTaprootAddress } from './get-taproot-address.js';
+export { getP2wshAddress } from './get-p2wsh-address.js';
+export { getP2wshInP2shAddress } from './get-p2wsh-in-p2sh-address.js';

package/build/browser/libs/modules/address/networks/common/get-btc-legacy-address.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../../libs/types/index.js';
+import { CommonKeyPair } from '../../../../types/types.js';
+import { PrefixConfig } from '../../../curves/curves.js';
+declare function getBtcLegacyAddress(publicKey: CommonKeyPair["publicKey"], prefixConfig: PrefixConfig): Address["address"];
+export { getBtcLegacyAddress };
+//# sourceMappingURL=get-btc-legacy-address.d.ts.map

package/build/browser/libs/modules/address/networks/common/get-btc-legacy-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-btc-legacy-address.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/common/get-btc-legacy-address.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,EACrC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,SAAS,CAAC,CAWpB;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/build/browser/libs/modules/address/networks/common/get-btc-legacy-address.js

@@ -0,0 +1,23 @@
+import '../../../../../prefix-config.type-BP_PoMwo.js';
+import { p as p2pkh } from '../../../../../p2pkh-CQ-LA34f.js';
+import '../../../../../index-DiZOBxXK.js';
+import '../../../../../browser-D9H9snNo.js';
+import { AddressError } from '../../libs/exceptions/address-error.exception.js';
+import { ExceptionMessage } from '../../libs/enums/exception-message.enum.js';
+import '../../../../../bip32-CTos7K79.js';
+import '../../../../../ecc-CVvMF8il.js';
+import '../../../../../index-Bsx2kz1h.js';
+import { convertHexToBytes } from '../../../../utils/convert-hex-to-bytes/convert-hex-to-bytes.util.js';
+import '../../../../../index-CjeBPB5t.js';
+
+function getBtcLegacyAddress(publicKey, prefixConfig) {
+  const rawPublicKey = convertHexToBytes(publicKey);
+  const { address } = p2pkh({
+    network: prefixConfig,
+    pubkey: rawPublicKey
+  });
+  if (!address) throw new AddressError(ExceptionMessage.ADDRESS_GENERATION_FAILED);
+  return address;
+}
+
+export { getBtcLegacyAddress };

package/build/browser/libs/modules/address/networks/common/get-btc-native-seg-wit-address.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../../libs/types/index.js';
+import { CommonKeyPair } from '../../../../types/types.js';
+import { PrefixConfig } from '../../../curves/curves.js';
+declare function getBtcNativeSegWitAddress(publicKey: CommonKeyPair["publicKey"], prefixConfig: PrefixConfig): Address["address"];
+export { getBtcNativeSegWitAddress };
+//# sourceMappingURL=get-btc-native-seg-wit-address.d.ts.map

package/build/browser/libs/modules/address/networks/common/get-btc-native-seg-wit-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-btc-native-seg-wit-address.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/common/get-btc-native-seg-wit-address.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,iBAAS,yBAAyB,CAChC,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,EACrC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,SAAS,CAAC,CAWpB;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/build/browser/libs/modules/address/networks/common/get-btc-native-seg-wit-address.js

@@ -0,0 +1,23 @@
+import '../../../../../prefix-config.type-BP_PoMwo.js';
+import '../../../../../index-DiZOBxXK.js';
+import { p as p2wpkh } from '../../../../../p2wpkh-g2Ewuefe.js';
+import '../../../../../browser-D9H9snNo.js';
+import { AddressError } from '../../libs/exceptions/address-error.exception.js';
+import { ExceptionMessage } from '../../libs/enums/exception-message.enum.js';
+import '../../../../../bip32-CTos7K79.js';
+import '../../../../../ecc-CVvMF8il.js';
+import '../../../../../index-Bsx2kz1h.js';
+import { convertHexToBytes } from '../../../../utils/convert-hex-to-bytes/convert-hex-to-bytes.util.js';
+import '../../../../../index-CjeBPB5t.js';
+
+function getBtcNativeSegWitAddress(publicKey, prefixConfig) {
+  const rawPublicKey = convertHexToBytes(publicKey);
+  const { address } = p2wpkh({
+    network: prefixConfig,
+    pubkey: rawPublicKey
+  });
+  if (!address) throw new AddressError(ExceptionMessage.ADDRESS_GENERATION_FAILED);
+  return address;
+}
+
+export { getBtcNativeSegWitAddress };

package/build/browser/libs/modules/address/networks/common/get-btc-seg-wit-address.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../../libs/types/index.js';
+import { CommonKeyPair } from '../../../../types/types.js';
+import { PrefixConfig } from '../../../curves/curves.js';
+declare function getBtcSegWitAddress(publicKey: CommonKeyPair["publicKey"], prefixConfig: PrefixConfig): Address["address"];
+export { getBtcSegWitAddress };
+//# sourceMappingURL=get-btc-seg-wit-address.d.ts.map

package/build/browser/libs/modules/address/networks/common/get-btc-seg-wit-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-btc-seg-wit-address.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/common/get-btc-seg-wit-address.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,EACrC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,SAAS,CAAC,CAapB;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/build/browser/libs/modules/address/networks/common/get-btc-seg-wit-address.js

@@ -0,0 +1,25 @@
+import '../../../../../prefix-config.type-BP_PoMwo.js';
+import '../../../../../index-DiZOBxXK.js';
+import { p as p2sh } from '../../../../../p2sh-DAS7N8JO.js';
+import { p as p2wpkh } from '../../../../../p2wpkh-g2Ewuefe.js';
+import '../../../../../browser-D9H9snNo.js';
+import { AddressError } from '../../libs/exceptions/address-error.exception.js';
+import { ExceptionMessage } from '../../libs/enums/exception-message.enum.js';
+import '../../../../../bip32-CTos7K79.js';
+import '../../../../../ecc-CVvMF8il.js';
+import '../../../../../index-Bsx2kz1h.js';
+import { convertHexToBytes } from '../../../../utils/convert-hex-to-bytes/convert-hex-to-bytes.util.js';
+import '../../../../../index-CjeBPB5t.js';
+
+function getBtcSegWitAddress(publicKey, prefixConfig) {
+  const rawPublicKey = convertHexToBytes(publicKey);
+  const redeem = p2wpkh({
+    pubkey: rawPublicKey,
+    network: prefixConfig
+  });
+  const { address } = p2sh({ redeem, network: prefixConfig });
+  if (!address) throw new AddressError(ExceptionMessage.ADDRESS_GENERATION_FAILED);
+  return address;
+}
+
+export { getBtcSegWitAddress };

package/build/browser/libs/modules/address/networks/common/index.d.ts

@@ -0,0 +1,2 @@
+export { getBtcLegacyAddress } from './get-btc-legacy-address.js';
+//# sourceMappingURL=index.d.ts.map

package/build/browser/libs/modules/address/networks/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC"}

package/build/browser/libs/modules/address/networks/common/index.js

@@ -0,0 +1 @@
+export { getBtcLegacyAddress } from './get-btc-legacy-address.js';

package/build/browser/libs/modules/address/networks/dot/get-dot-address.d.ts

@@ -0,0 +1,4 @@
+import { Ss58Format } from './libs/types/index.js';
+declare function getDotAddress(publicKey: string, ss58Format: Ss58Format["ss58Format"]): string;
+export { getDotAddress };
+//# sourceMappingURL=get-dot-address.d.ts.map

package/build/browser/libs/modules/address/networks/dot/get-dot-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-dot-address.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/address/networks/dot/get-dot-address.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AASxD,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,UAa7E;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}