@btc-vision/bitcoin 6.3.1 → 6.3.3

package/src/{address.js → address.ts}

@@ -1,191 +1,211 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.toOutputScript =
-    exports.fromOutputScript =
-    exports.toBech32 =
-    exports.toBase58Check =
-    exports.fromBech32 =
-    exports.fromBase58Check =
-        void 0;
-/**
- * bitcoin address decode and encode tools, include base58、bech32 and output script
- *
- * networks support bitcoin、bitcoin testnet and bitcoin regtest
- *
- * addresses support P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
- *
- * @packageDocumentation
- */
-const networks = require('./networks');
-const payments = require('./payments');
-const bscript = require('./script');
-const types_1 = require('./types');
-const bech32_1 = require('bech32');
-const bs58check = require('bs58check');
-const FUTURE_SEGWIT_MAX_SIZE = 40;
-const FUTURE_SEGWIT_MIN_SIZE = 2;
-const FUTURE_SEGWIT_MAX_VERSION = 16;
-const FUTURE_SEGWIT_MIN_VERSION = 2;
-const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
-const FUTURE_SEGWIT_VERSION_WARNING =
-    'WARNING: Sending to a future segwit version address can lead to loss of funds. ' +
-    'End users MUST be warned carefully in the GUI and asked if they wish to proceed ' +
-    'with caution. Wallets should verify the segwit version from the output of fromBech32, ' +
-    'then decide when it is safe to use which version of segwit.';
-function _toFutureSegwitAddress(output, network) {
-    const data = output.slice(2);
-    if (
-        data.length < FUTURE_SEGWIT_MIN_SIZE ||
-        data.length > FUTURE_SEGWIT_MAX_SIZE
-    )
-        throw new TypeError('Invalid program length for segwit address');
-    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
-    if (
-        version < FUTURE_SEGWIT_MIN_VERSION ||
-        version > FUTURE_SEGWIT_MAX_VERSION
-    )
-        throw new TypeError('Invalid version for segwit address');
-    if (output[1] !== data.length)
-        throw new TypeError('Invalid script for segwit address');
-    console.warn(FUTURE_SEGWIT_VERSION_WARNING);
-    return toBech32(data, version, network.bech32);
-}
-/**
- * decode address with base58 specification,  return address version and address hash if valid
- */
-function fromBase58Check(address) {
-    const payload = Buffer.from(bs58check.decode(address));
-    // TODO: 4.0.0, move to "toOutputScript"
-    if (payload.length < 21) throw new TypeError(address + ' is too short');
-    if (payload.length > 21) throw new TypeError(address + ' is too long');
-    const version = payload.readUInt8(0);
-    const hash = payload.slice(1);
-    return { version, hash };
-}
-exports.fromBase58Check = fromBase58Check;
-/**
- * decode address with bech32 specification,  return address version、address prefix and address data if valid
- */
-function fromBech32(address) {
-    let result;
-    let version;
-    try {
-        result = bech32_1.bech32.decode(address);
-    } catch (e) {}
-    if (result) {
-        version = result.words[0];
-        if (version !== 0)
-            throw new TypeError(address + ' uses wrong encoding');
-    } else {
-        result = bech32_1.bech32m.decode(address);
-        version = result.words[0];
-        if (version === 0)
-            throw new TypeError(address + ' uses wrong encoding');
-    }
-    const data = bech32_1.bech32.fromWords(result.words.slice(1));
-    return {
-        version,
-        prefix: result.prefix,
-        data: Buffer.from(data),
-    };
-}
-exports.fromBech32 = fromBech32;
-/**
- * encode address hash to base58 address with version
- */
-function toBase58Check(hash, version) {
-    (0, types_1.typeforce)(
-        (0, types_1.tuple)(types_1.Hash160bit, types_1.UInt8),
-        arguments,
-    );
-    const payload = Buffer.allocUnsafe(21);
-    payload.writeUInt8(version, 0);
-    hash.copy(payload, 1);
-    return bs58check.encode(payload);
-}
-exports.toBase58Check = toBase58Check;
-/**
- * encode address hash to bech32 address with version and prefix
- */
-function toBech32(data, version, prefix) {
-    const words = bech32_1.bech32.toWords(data);
-    words.unshift(version);
-    return version === 0
-        ? bech32_1.bech32.encode(prefix, words)
-        : bech32_1.bech32m.encode(prefix, words);
-}
-exports.toBech32 = toBech32;
-/**
- * decode address from output script with network, return address if matched
- */
-function fromOutputScript(output, network) {
-    // TODO: Network
-    network = network || networks.bitcoin;
-    try {
-        return payments.p2pkh({ output, network }).address;
-    } catch (e) {}
-    try {
-        return payments.p2sh({ output, network }).address;
-    } catch (e) {}
-    try {
-        return payments.p2wpkh({ output, network }).address;
-    } catch (e) {}
-    try {
-        return payments.p2wsh({ output, network }).address;
-    } catch (e) {}
-    try {
-        return payments.p2tr({ output, network }).address;
-    } catch (e) {}
-    try {
-        return _toFutureSegwitAddress(output, network);
-    } catch (e) {}
-    throw new Error(bscript.toASM(output) + ' has no matching Address');
-}
-exports.fromOutputScript = fromOutputScript;
-/**
- * encodes address to output script with network, return output script if address matched
- */
-function toOutputScript(address, network) {
-    network = network || networks.bitcoin;
-    let decodeBase58;
-    let decodeBech32;
-    try {
-        decodeBase58 = fromBase58Check(address);
-    } catch (e) {}
-    if (decodeBase58) {
-        if (decodeBase58.version === network.pubKeyHash)
-            return payments.p2pkh({ hash: decodeBase58.hash }).output;
-        if (decodeBase58.version === network.scriptHash)
-            return payments.p2sh({ hash: decodeBase58.hash }).output;
-    } else {
-        try {
-            decodeBech32 = fromBech32(address);
-        } catch (e) {}
-        if (decodeBech32) {
-            if (decodeBech32.prefix !== network.bech32)
-                throw new Error(address + ' has an invalid prefix');
-            if (decodeBech32.version === 0) {
-                if (decodeBech32.data.length === 20)
-                    return payments.p2wpkh({ hash: decodeBech32.data }).output;
-                if (decodeBech32.data.length === 32)
-                    return payments.p2wsh({ hash: decodeBech32.data }).output;
-            } else if (decodeBech32.version === 1) {
-                if (decodeBech32.data.length === 32)
-                    return payments.p2tr({ pubkey: decodeBech32.data }).output;
-            } else if (
-                decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
-                decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&
-                decodeBech32.data.length >= FUTURE_SEGWIT_MIN_SIZE &&
-                decodeBech32.data.length <= FUTURE_SEGWIT_MAX_SIZE
-            ) {
-                console.warn(FUTURE_SEGWIT_VERSION_WARNING);
-                return bscript.compile([
-                    decodeBech32.version + FUTURE_SEGWIT_VERSION_DIFF,
-                    decodeBech32.data,
-                ]);
-            }
-        }
-    }
-    return Buffer.from(address, 'hex');
-}
-exports.toOutputScript = toOutputScript;
+/**
+ * bitcoin address decode and encode tools, include base58、bech32 and output script
+ *
+ * networks support bitcoin、bitcoin testnet and bitcoin regtest
+ *
+ * addresses support P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
+ *
+ * @packageDocumentation
+ */
+import { bech32, bech32m } from 'bech32';
+import * as bs58check from 'bs58check';
+import { payments } from './index.js';
+import * as networks from './networks.js';
+import { Network } from './networks.js';
+import * as bscript from './script.js';
+import { Hash160bit, tuple, typeforce, UInt8 } from './types.js';
+
+/** base58check decode result */
+export interface Base58CheckResult {
+    /** address hash */
+    hash: Buffer;
+    /** address version: 0x00 for P2PKH, 0x05 for P2SH */
+    version: number;
+}
+
+/** bech32 decode result */
+export interface Bech32Result {
+    /** address version: 0x00 for P2WPKH、P2WSH, 0x01 for P2TR*/
+    version: number;
+    /** address prefix: bc for P2WPKH、P2WSH、P2TR */
+    prefix: string;
+    /** address data：20 bytes for P2WPKH, 32 bytes for P2WSH、P2TR */
+    data: Buffer;
+}
+
+const FUTURE_SEGWIT_MAX_SIZE: number = 40;
+const FUTURE_SEGWIT_MIN_SIZE: number = 2;
+const FUTURE_SEGWIT_MAX_VERSION: number = 16;
+const FUTURE_SEGWIT_MIN_VERSION: number = 2;
+const FUTURE_SEGWIT_VERSION_DIFF: number = 0x50;
+const FUTURE_SEGWIT_VERSION_WARNING: string =
+    'WARNING: Sending to a future segwit version address can lead to loss of funds. ' +
+    'End users MUST be warned carefully in the GUI and asked if they wish to proceed ' +
+    'with caution. Wallets should verify the segwit version from the output of fromBech32, ' +
+    'then decide when it is safe to use which version of segwit.';
+
+function _toFutureSegwitAddress(output: Buffer, network: Network): string {
+    const data = output.slice(2);
+
+    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE)
+        throw new TypeError('Invalid program length for segwit address');
+
+    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
+
+    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION)
+        throw new TypeError('Invalid version for segwit address');
+
+    if (output[1] !== data.length) throw new TypeError('Invalid script for segwit address');
+
+    console.warn(FUTURE_SEGWIT_VERSION_WARNING);
+
+    return toBech32(data, version, network.bech32);
+}
+
+/**
+ * decode address with base58 specification,  return address version and address hash if valid
+ */
+export function fromBase58Check(address: string): Base58CheckResult {
+    const payload = Buffer.from(bs58check.default.decode(address));
+
+    // TODO: 4.0.0, move to "toOutputScript"
+    if (payload.length < 21) throw new TypeError(address + ' is too short');
+    if (payload.length > 21) throw new TypeError(address + ' is too long');
+
+    const version = payload.readUInt8(0);
+    const hash = payload.slice(1);
+
+    return { version, hash };
+}
+
+/**
+ * decode address with bech32 specification,  return address version、address prefix and address data if valid
+ */
+export function fromBech32(address: string): Bech32Result {
+    let result;
+    let version;
+    try {
+        result = bech32.decode(address);
+    } catch (e) {}
+
+    if (result) {
+        version = result.words[0];
+        if (version !== 0) throw new TypeError(address + ' uses wrong encoding');
+    } else {
+        result = bech32m.decode(address);
+        version = result.words[0];
+        if (version === 0) throw new TypeError(address + ' uses wrong encoding');
+    }
+
+    const data = bech32.fromWords(result.words.slice(1));
+
+    return {
+        version,
+        prefix: result.prefix,
+        data: Buffer.from(data),
+    };
+}
+
+/**
+ * encode address hash to base58 address with version
+ */
+export function toBase58Check(hash: Buffer, version: number): string {
+    typeforce(tuple(Hash160bit, UInt8), arguments);
+
+    const payload = Buffer.allocUnsafe(21);
+    payload.writeUInt8(version, 0);
+    hash.copy(payload, 1);
+
+    return bs58check.default.encode(payload);
+}
+
+/**
+ * encode address hash to bech32 address with version and prefix
+ */
+export function toBech32(data: Buffer, version: number, prefix: string): string {
+    const words = bech32.toWords(data);
+    words.unshift(version);
+
+    return version === 0 ? bech32.encode(prefix, words) : bech32m.encode(prefix, words);
+}
+
+/**
+ * decode address from output script with network, return address if matched
+ */
+export function fromOutputScript(output: Buffer, network?: Network): string {
+    // TODO: Network
+    network = network || networks.bitcoin;
+
+    try {
+        return payments.p2pkh({ output, network }).address as string;
+    } catch (e) {}
+    try {
+        return payments.p2sh({ output, network }).address as string;
+    } catch (e) {}
+    try {
+        return payments.p2wpkh({ output, network }).address as string;
+    } catch (e) {}
+    try {
+        return payments.p2wsh({ output, network }).address as string;
+    } catch (e) {}
+    try {
+        return payments.p2tr({ output, network }).address as string;
+    } catch (e) {}
+    try {
+        return _toFutureSegwitAddress(output, network);
+    } catch (e) {}
+
+    throw new Error(bscript.toASM(output) + ' has no matching Address');
+}
+
+/**
+ * encodes address to output script with network, return output script if address matched
+ */
+export function toOutputScript(address: string, network?: Network): Buffer {
+    network = network || networks.bitcoin;
+
+    let decodeBase58: Base58CheckResult | undefined;
+    let decodeBech32: Bech32Result | undefined;
+    try {
+        decodeBase58 = fromBase58Check(address);
+    } catch (e) {}
+
+    if (decodeBase58) {
+        if (decodeBase58.version === network.pubKeyHash)
+            return payments.p2pkh({ hash: decodeBase58.hash }).output as Buffer;
+        if (decodeBase58.version === network.scriptHash)
+            return payments.p2sh({ hash: decodeBase58.hash }).output as Buffer;
+    } else {
+        try {
+            decodeBech32 = fromBech32(address);
+        } catch (e) {}
+
+        if (decodeBech32) {
+            if (decodeBech32.prefix !== network.bech32)
+                throw new Error(address + ' has an invalid prefix');
+            if (decodeBech32.version === 0) {
+                if (decodeBech32.data.length === 20)
+                    return payments.p2wpkh({ hash: decodeBech32.data }).output as Buffer;
+                if (decodeBech32.data.length === 32)
+                    return payments.p2wsh({ hash: decodeBech32.data }).output as Buffer;
+            } else if (decodeBech32.version === 1) {
+                if (decodeBech32.data.length === 32)
+                    return payments.p2tr({ pubkey: decodeBech32.data }).output as Buffer;
+            } else if (
+                decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
+                decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&
+                decodeBech32.data.length >= FUTURE_SEGWIT_MIN_SIZE &&
+                decodeBech32.data.length <= FUTURE_SEGWIT_MAX_SIZE
+            ) {
+                console.warn(FUTURE_SEGWIT_VERSION_WARNING);
+
+                return bscript.compile([
+                    decodeBech32.version + FUTURE_SEGWIT_VERSION_DIFF,
+                    decodeBech32.data,
+                ]);
+            }
+        }
+    }
+
+    return Buffer.from(address, 'hex');
+}

package/src/{bip66.js → bip66.ts}

@@ -1,58 +1,62 @@
-'use strict';
 // Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
 // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
 // NOTE: SIGHASH byte ignored AND restricted, truncate before use
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.encode = exports.decode = exports.check = void 0;
-function check(buffer) {
+
+export function check(buffer: Buffer): boolean {
     if (buffer.length < 8) return false;
     if (buffer.length > 72) return false;
     if (buffer[0] !== 0x30) return false;
     if (buffer[1] !== buffer.length - 2) return false;
     if (buffer[2] !== 0x02) return false;
+
     const lenR = buffer[3];
     if (lenR === 0) return false;
     if (5 + lenR >= buffer.length) return false;
     if (buffer[4 + lenR] !== 0x02) return false;
+
     const lenS = buffer[5 + lenR];
     if (lenS === 0) return false;
     if (6 + lenR + lenS !== buffer.length) return false;
+
     if (buffer[4] & 0x80) return false;
     if (lenR > 1 && buffer[4] === 0x00 && !(buffer[5] & 0x80)) return false;
+
     if (buffer[lenR + 6] & 0x80) return false;
-    if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
-        return false;
+    if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80)) return false;
     return true;
 }
-exports.check = check;
-function decode(buffer) {
+
+export function decode(buffer: Buffer): { r: Buffer; s: Buffer } {
     if (buffer.length < 8) throw new Error('DER sequence length is too short');
     if (buffer.length > 72) throw new Error('DER sequence length is too long');
     if (buffer[0] !== 0x30) throw new Error('Expected DER sequence');
-    if (buffer[1] !== buffer.length - 2)
-        throw new Error('DER sequence length is invalid');
+    if (buffer[1] !== buffer.length - 2) throw new Error('DER sequence length is invalid');
     if (buffer[2] !== 0x02) throw new Error('Expected DER integer');
+
     const lenR = buffer[3];
     if (lenR === 0) throw new Error('R length is zero');
     if (5 + lenR >= buffer.length) throw new Error('R length is too long');
     if (buffer[4 + lenR] !== 0x02) throw new Error('Expected DER integer (2)');
+
     const lenS = buffer[5 + lenR];
     if (lenS === 0) throw new Error('S length is zero');
-    if (6 + lenR + lenS !== buffer.length)
-        throw new Error('S length is invalid');
+    if (6 + lenR + lenS !== buffer.length) throw new Error('S length is invalid');
+
     if (buffer[4] & 0x80) throw new Error('R value is negative');
     if (lenR > 1 && buffer[4] === 0x00 && !(buffer[5] & 0x80))
         throw new Error('R value excessively padded');
+
     if (buffer[lenR + 6] & 0x80) throw new Error('S value is negative');
     if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
         throw new Error('S value excessively padded');
+
     // non-BIP66 - extract R, S values
     return {
         r: buffer.slice(4, 4 + lenR),
         s: buffer.slice(6 + lenR),
     };
 }
-exports.decode = decode;
+
 /*
  * Expects r and s to be positive DER integers.
  *
@@ -75,7 +79,7 @@ exports.decode = decode;
  *  62300 => 0x00f35c
  * -62300 => 0xff0ca4
  */
-function encode(r, s) {
+export function encode(r: Buffer, s: Buffer): Buffer {
     const lenR = r.length;
     const lenS = s.length;
     if (lenR === 0) throw new Error('R length is zero');
@@ -84,11 +88,11 @@ function encode(r, s) {
     if (lenS > 33) throw new Error('S length is too long');
     if (r[0] & 0x80) throw new Error('R value is negative');
     if (s[0] & 0x80) throw new Error('S value is negative');
-    if (lenR > 1 && r[0] === 0x00 && !(r[1] & 0x80))
-        throw new Error('R value excessively padded');
-    if (lenS > 1 && s[0] === 0x00 && !(s[1] & 0x80))
-        throw new Error('S value excessively padded');
+    if (lenR > 1 && r[0] === 0x00 && !(r[1] & 0x80)) throw new Error('R value excessively padded');
+    if (lenS > 1 && s[0] === 0x00 && !(s[1] & 0x80)) throw new Error('S value excessively padded');
+
     const signature = Buffer.allocUnsafe(6 + lenR + lenS);
+
     // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
     signature[0] = 0x30;
     signature[1] = signature.length - 2;
@@ -98,6 +102,6 @@ function encode(r, s) {
     signature[4 + lenR] = 0x02;
     signature[5 + lenR] = s.length;
     s.copy(signature, 6 + lenR);
+
     return signature;
 }
-exports.encode = encode;