@vbyte/btc-dev 1.1.3 → 1.1.5

package/dist/main.cjs

@@ -8244,15 +8244,135 @@ function bech32m_decode(encoded) {
     return { data, format: 'bech32m', prefix, version };
 }
 
+const COINBASE = {
+    TXID: '00'.repeat(32),
+    VOUT: 0xFFFFFFFF,
+};
+const DEFAULT = {
+    LOCKTIME: 0,
+    SEQUENCE: 0xFFFFFFFF,
+    VERSION: 2,
+};
+const TAPLEAF_VERSIONS = [
+    0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
+    0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
+    0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
+    0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
+    0x66, 0x7e, 0x80, 0x84, 0x96, 0x98, 0xba, 0xbc,
+    0xbe
+];
+const TAPLEAF_DEFAULT_VERSION = 0xc0;
+const LOCK_SCRIPT_TYPE = {
+    P2PKH: 'p2pkh',
+    P2SH: 'p2sh',
+    P2WPKH: 'p2wpkh',
+    P2WSH: 'p2wsh',
+    P2TR: 'p2tr',
+    OPRETURN: 'opreturn',
+};
+const SPEND_SCRIPT_TYPE = {
+    P2PKH: 'p2pkh',
+    P2SH: 'p2sh',
+    P2WPKH: 'p2wpkh',
+    P2WSH: 'p2wsh',
+    P2TR: 'p2tr',
+    P2TS: 'p2ts',
+};
+const LOCK_SCRIPT_REGEX = {
+    [LOCK_SCRIPT_TYPE.P2PKH]: /^76a914[0-9a-f]{40}88ac$/i,
+    [LOCK_SCRIPT_TYPE.P2SH]: /^a914[0-9a-f]{40}87$/i,
+    [LOCK_SCRIPT_TYPE.P2WPKH]: /^0014[0-9a-f]{40}$/i,
+    [LOCK_SCRIPT_TYPE.P2WSH]: /^0020[0-9a-f]{64}$/i,
+    [LOCK_SCRIPT_TYPE.P2TR]: /^5120[0-9a-f]{64}$/i,
+    [LOCK_SCRIPT_TYPE.OPRETURN]: /^6a[0-9a-f]{2,}$/i,
+};
+const SCRIPT_INT_KEY = '';
+const TX_SIZE = {
+    GLOBAL_BASE: 8,
+    GLOBAL_WIT: 10,
+    TXIN_BASE: 32 + 4 + 4,
+    TXOUT_BASE: 8,
+};
+const SIGHASH_DEFAULT = 0x01;
+const SIGHASH_SEGWIT = [0x01, 0x02, 0x03, 0x81, 0x82, 0x83];
+const SIGHASH_TAPROOT = [0x00, ...SIGHASH_SEGWIT];
+
+var _const = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    COINBASE: COINBASE,
+    DEFAULT: DEFAULT,
+    LOCK_SCRIPT_REGEX: LOCK_SCRIPT_REGEX,
+    LOCK_SCRIPT_TYPE: LOCK_SCRIPT_TYPE,
+    SCRIPT_INT_KEY: SCRIPT_INT_KEY,
+    SIGHASH_DEFAULT: SIGHASH_DEFAULT,
+    SIGHASH_SEGWIT: SIGHASH_SEGWIT,
+    SIGHASH_TAPROOT: SIGHASH_TAPROOT,
+    SPEND_SCRIPT_TYPE: SPEND_SCRIPT_TYPE,
+    TAPLEAF_DEFAULT_VERSION: TAPLEAF_DEFAULT_VERSION,
+    TAPLEAF_VERSIONS: TAPLEAF_VERSIONS,
+    TX_SIZE: TX_SIZE
+});
+
+function is_return_script(script) {
+    const bytes = Buff.bytes(script);
+    return bytes.at(0) === 0x6a;
+}
+function get_lock_script_info(script) {
+    return {
+        type: get_lock_script_type(script),
+        version: get_lock_script_version(script)
+    };
+}
+function get_lock_script_type(script) {
+    const hex = Buff.bytes(script).hex;
+    for (const [type, regex] of Object.entries(LOCK_SCRIPT_REGEX)) {
+        if (regex.test(hex))
+            return type;
+    }
+    return null;
+}
+function get_lock_script_version(script) {
+    const version = Buff.bytes(script);
+    switch (version.at(0)) {
+        case 0x00: return 0;
+        case 0x51: return 1;
+        default: return null;
+    }
+}
+function is_p2pkh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2pkh'].test(hex);
+}
+function is_p2sh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2sh'].test(hex);
+}
+function is_p2wpkh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2wpkh'].test(hex);
+}
+function is_p2wsh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2wsh'].test(hex);
+}
+function is_p2tr_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2tr'].test(hex);
+}
+function is_opreturn_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['opreturn'].test(hex);
+}
+
 function get_address_script(script_key, script_type) {
     switch (script_type) {
         case 'p2pkh':
             return get_p2pkh_script(script_key);
         case 'p2sh':
             return get_p2sh_script(script_key);
-        case 'p2w-pkh':
+        case 'p2wpkh':
             return get_p2w_pkh_script(script_key);
-        case 'p2w-sh':
+        case 'p2wsh':
             return get_p2w_sh_script(script_key);
         case 'p2tr':
             return get_p2tr_script(script_key);
@@ -8262,32 +8382,32 @@ function get_address_script(script_key, script_type) {
 }
 function get_p2pkh_script(script_key) {
     return {
-        script_hex: '76a914' + script_key + '88ac',
-        script_asm: ['OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG']
+        hex: '76a914' + script_key + '88ac',
+        asm: ['OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG']
     };
 }
 function get_p2sh_script(script_key) {
     return {
-        script_hex: 'a914' + script_key + '87',
-        script_asm: ['OP_HASH160', script_key, 'OP_EQUAL']
+        hex: 'a914' + script_key + '87',
+        asm: ['OP_HASH160', script_key, 'OP_EQUAL']
     };
 }
 function get_p2w_pkh_script(script_key) {
     return {
-        script_hex: '0014' + script_key,
-        script_asm: ['OP_0', script_key]
+        hex: '0014' + script_key,
+        asm: ['OP_0', script_key]
     };
 }
 function get_p2w_sh_script(script_key) {
     return {
-        script_hex: '0020' + script_key,
-        script_asm: ['OP_0', script_key]
+        hex: '0020' + script_key,
+        asm: ['OP_0', script_key]
     };
 }
 function get_p2tr_script(script_key) {
     return {
-        script_hex: '5120' + script_key,
-        script_asm: ['OP_1', script_key]
+        hex: '5120' + script_key,
+        asm: ['OP_1', script_key]
     };
 }
 
@@ -8300,12 +8420,12 @@ const CONFIG_TABLE = [
     ['m', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
     ['n', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
     ['2', 'p2sh', 'regtest', 20, 'base58', 0xC4],
-    ['bc', 'p2w-pkh', 'main', 20, 'bech32', 0],
-    ['tb', 'p2w-pkh', 'testnet', 20, 'bech32', 0],
-    ['bcrt', 'p2w-pkh', 'regtest', 20, 'bech32', 0],
-    ['bc', 'p2w-sh', 'main', 32, 'bech32', 0],
-    ['tb', 'p2w-sh', 'testnet', 32, 'bech32', 0],
-    ['bcrt', 'p2w-sh', 'regtest', 32, 'bech32', 0],
+    ['bc', 'p2wpkh', 'main', 20, 'bech32', 0],
+    ['tb', 'p2wpkh', 'testnet', 20, 'bech32', 0],
+    ['bcrt', 'p2wpkh', 'regtest', 20, 'bech32', 0],
+    ['bc', 'p2wsh', 'main', 32, 'bech32', 0],
+    ['tb', 'p2wsh', 'testnet', 32, 'bech32', 0],
+    ['bcrt', 'p2wsh', 'regtest', 32, 'bech32', 0],
     ['bc', 'p2tr', 'main', 32, 'bech32m', 1],
     ['tb', 'p2tr', 'testnet', 32, 'bech32m', 1],
     ['bcrt', 'p2tr', 'regtest', 32, 'bech32m', 1]
@@ -8318,7 +8438,7 @@ function get_address_config(address_network, address_type) {
     }
     return null;
 }
-function get_address_ctx(address) {
+function get_address_info(address) {
     const dec = decode_address(address);
     for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
         if (format !== dec.format)
@@ -8335,175 +8455,269 @@ function get_address_ctx(address) {
             if (!address.startsWith(prefix))
                 continue;
         }
-        const hex = Buff.uint(dec.data).hex;
-        return { data: dec.data, hex, type, prefix, network, size, format, version };
+        const data = Buff.uint(dec.data).hex;
+        const script = get_address_script(data, type);
+        return { data, script, type, prefix, network, size, format, version };
     }
     throw new Error('address configuration is invalid');
 }
-function parse_address(address) {
-    const ctx = get_address_ctx(address);
-    const script = get_address_script(ctx.hex, ctx.type);
-    return { ...ctx, ...script };
-}
 
-const ADDR_TYPE$4 = 'p2pkh';
+const ADDRESS_TYPE$4 = LOCK_SCRIPT_TYPE.P2PKH;
 var P2PKH;
 (function (P2PKH) {
-    P2PKH.create = create_p2pkh_address;
-    P2PKH.encode = encode_p2pkh_address;
-    P2PKH.decode = decode_p2pkh_address;
+    P2PKH.create_address = create_p2pkh_address;
+    P2PKH.create_script = create_p2pkh_script;
+    P2PKH.encode_address = encode_p2pkh_address;
+    P2PKH.encode_script = encode_p2pkh_script;
+    P2PKH.decode_address = decode_p2pkh_address;
+    P2PKH.decode_script = decode_p2pkh_script;
 })(P2PKH || (P2PKH = {}));
-function create_p2pkh_address(script, network = 'main') {
-    const bytes = Buff.bytes(script);
+function create_p2pkh_address(pubkey, network = 'main') {
+    const script = create_p2pkh_script(pubkey);
+    return encode_p2pkh_address(script, network);
+}
+function create_p2pkh_script(pubkey) {
+    const bytes = Buff.bytes(pubkey);
+    Assert.size(bytes, 33, 'invalid pubkey size');
     const hash = hash160(bytes);
-    return encode_p2pkh_address(hash, network);
+    return encode_p2pkh_script(hash);
+}
+function encode_p2pkh_script(pk_hash) {
+    return Buff.join(['76a914', pk_hash, '88ac']);
 }
-function encode_p2pkh_address(pk_hash, network = 'main') {
-    const bytes = Buff.bytes(pk_hash);
-    const config = get_address_config(network, ADDR_TYPE$4);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$4} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+function encode_p2pkh_address(script, network = 'main') {
+    const pk_hash = decode_p2pkh_script(script);
+    const config = get_address_config(network, ADDRESS_TYPE$4);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE$4} on ${network}`);
+    Assert.size(pk_hash, config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
     return encode_address({
-        data: bytes,
+        data: pk_hash,
         format: 'base58',
         version: config.version
     });
 }
 function decode_p2pkh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$4}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE$4}`);
     return parsed;
 }
+function decode_p2pkh_script(script) {
+    const bytes = Buff.bytes(script);
+    Assert.ok(is_p2pkh_script(script), `invalid p2pkh script`);
+    return bytes.slice(3, 23);
+}
 
-const ADDR_TYPE$3 = 'p2sh';
+const ADDRESS_TYPE$3 = LOCK_SCRIPT_TYPE.P2SH;
 var P2SH;
 (function (P2SH) {
-    P2SH.create = create_p2sh_address;
-    P2SH.encode = encode_p2sh_address;
-    P2SH.decode = decode_p2sh_address;
+    P2SH.create_address = create_p2sh_address;
+    P2SH.create_script = create_p2sh_script;
+    P2SH.encode_address = encode_p2sh_address;
+    P2SH.encode_script = encode_p2sh_script;
+    P2SH.decode_address = decode_p2sh_address;
+    P2SH.decode_script = decode_p2sh_script;
 })(P2SH || (P2SH = {}));
 function create_p2sh_address(script, network = 'main') {
     const bytes = Buff.bytes(script);
     const hash = hash160(bytes);
-    return encode_p2sh_address(hash, network);
+    const p2sh_script = encode_p2sh_script(hash);
+    return encode_p2sh_address(p2sh_script, network);
+}
+function create_p2sh_script(script) {
+    const bytes = Buff.bytes(script);
+    const hash = hash160(bytes);
+    return encode_p2sh_script(hash);
+}
+function encode_p2sh_script(script_hash) {
+    return Buff.join(['a914', script_hash, '87']);
 }
-function encode_p2sh_address(script_hash, network = 'main') {
-    const bytes = Buff.bytes(script_hash);
-    const config = get_address_config(network, ADDR_TYPE$3);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$3} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+function encode_p2sh_address(script_pk, network = 'main') {
+    const script_hash = decode_p2sh_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE$3);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE$3} on ${network}`);
+    Assert.size(script_hash, config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
     return encode_address({
-        data: bytes,
+        data: script_hash,
         format: 'base58',
         version: config.version
     });
 }
 function decode_p2sh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$3}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE$3}`);
     return parsed;
 }
+function decode_p2sh_script(script) {
+    Assert.ok(is_p2sh_script(script), `invalid p2sh script`);
+    const bytes = Buff.bytes(script);
+    return bytes.slice(2, 22);
+}
 
-const ADDR_TYPE$2 = 'p2w-pkh';
+const ADDRESS_TYPE$2 = LOCK_SCRIPT_TYPE.P2WPKH;
 var P2WPKH;
 (function (P2WPKH) {
-    P2WPKH.create = create_p2wpkh_address;
-    P2WPKH.encode = encode_p2wpkh_address;
-    P2WPKH.decode = decode_p2wpkh_address;
+    P2WPKH.create_address = create_p2wpkh_address;
+    P2WPKH.create_script = create_p2wpkh_script;
+    P2WPKH.encode_address = encode_p2wpkh_address;
+    P2WPKH.encode_script = encode_p2wpkh_script;
+    P2WPKH.decode_address = decode_p2wpkh_address;
+    P2WPKH.decode_script = decode_p2wpkh_script;
 })(P2WPKH || (P2WPKH = {}));
 function create_p2wpkh_address(pubkey, network = 'main') {
+    const script = create_p2wpkh_script(pubkey);
+    return encode_p2wpkh_address(script, network);
+}
+function create_p2wpkh_script(pubkey) {
     const bytes = Buff.bytes(pubkey);
-    Assert.size(bytes, 33, `invalid payload size: ${bytes.length} !== 33`);
+    Assert.size(bytes, 33, 'invalid pubkey size');
     const hash = hash160(bytes);
-    return encode_p2wpkh_address(hash, network);
+    return encode_p2wpkh_script(hash);
 }
-function encode_p2wpkh_address(pk_hash, network = 'main') {
-    const bytes = Buff.bytes(pk_hash);
-    const config = get_address_config(network, ADDR_TYPE$2);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$2} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+function encode_p2wpkh_script(pk_hash) {
+    return Buff.join(['0014', pk_hash]);
+}
+function encode_p2wpkh_address(script_pk, network = 'main') {
+    const pk_hash = decode_p2wpkh_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE$2);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE$2} on ${network}`);
+    Assert.size(pk_hash, config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
     return encode_address({
-        data: bytes,
+        data: pk_hash,
         format: 'bech32',
         prefix: config.prefix
     });
 }
 function decode_p2wpkh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2w-pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$2}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2wpkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE$2}`);
     return parsed;
 }
+function decode_p2wpkh_script(script) {
+    Assert.ok(is_p2wpkh_script(script), `invalid p2wpkh script`);
+    const bytes = Buff.bytes(script);
+    return bytes.slice(2, 22);
+}
 
-const ADDR_TYPE$1 = 'p2w-sh';
+const ADDRESS_TYPE$1 = LOCK_SCRIPT_TYPE.P2WSH;
 var P2WSH;
 (function (P2WSH) {
-    P2WSH.create = create_p2wsh_address;
-    P2WSH.encode = encode_p2wsh_address;
-    P2WSH.decode = decode_p2wsh_address;
+    P2WSH.create_address = create_p2wsh_address;
+    P2WSH.create_script = create_p2wsh_script;
+    P2WSH.encode_address = encode_p2wsh_address;
+    P2WSH.encode_script = encode_p2wsh_script;
+    P2WSH.decode_address = decode_p2wsh_address;
+    P2WSH.decode_script = decode_p2wsh_script;
 })(P2WSH || (P2WSH = {}));
 function create_p2wsh_address(script, network = 'main') {
+    const wsh_script = create_p2wsh_script(script);
+    return encode_p2wsh_address(wsh_script, network);
+}
+function create_p2wsh_script(script) {
     const bytes = Buff.bytes(script);
     const hash = sha256(bytes);
-    return encode_p2wsh_address(hash, network);
+    return encode_p2wsh_script(hash);
+}
+function encode_p2wsh_script(script_hash) {
+    return Buff.join(['0020', script_hash]);
 }
-function encode_p2wsh_address(script_hash, network = 'main') {
-    const bytes = Buff.bytes(script_hash);
-    const config = get_address_config(network, ADDR_TYPE$1);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$1} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+function encode_p2wsh_address(script_pk, network = 'main') {
+    const script_hash = decode_p2wsh_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE$1);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE$1} on ${network}`);
+    Assert.size(script_hash, config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
     return encode_address({
-        data: bytes,
+        data: script_hash,
         format: 'bech32',
         prefix: config.prefix
     });
 }
 function decode_p2wsh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2w-sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$1}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2wsh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE$1}`);
     return parsed;
 }
+function decode_p2wsh_script(script) {
+    Assert.ok(is_p2wsh_script(script), `invalid p2wsh script`);
+    const bytes = Buff.bytes(script);
+    return bytes.slice(2, 34);
+}
 
-const ADDR_TYPE = 'p2tr';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2TR;
 var P2TR;
 (function (P2TR) {
-    P2TR.encode = encode_p2tr_address;
-    P2TR.decode = decode_p2tr_address;
+    P2TR.create_address = create_p2tr_address;
+    P2TR.create_script = create_p2tr_script;
+    P2TR.encode_address = encode_p2tr_address;
+    P2TR.encode_script = encode_p2tr_script;
+    P2TR.decode_address = decode_p2tr_address;
+    P2TR.decode_script = decode_p2tr_script;
 })(P2TR || (P2TR = {}));
-function encode_p2tr_address(pubkey, network = 'main') {
+function create_p2tr_address(pubkey, network = 'main') {
+    const script = create_p2tr_script(pubkey);
+    return encode_p2tr_address(script, network);
+}
+function create_p2tr_script(pubkey) {
     const bytes = Buff.bytes(pubkey);
-    const config = get_address_config(network, ADDR_TYPE);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    Assert.size(bytes, 32, 'invalid pubkey size');
+    return encode_p2tr_script(bytes);
+}
+function encode_p2tr_script(pubkey) {
+    return Buff.join(['5120', pubkey]);
+}
+function encode_p2tr_address(script_pk, network = 'main') {
+    const pubkey = decode_p2tr_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} on ${network}`);
+    Assert.size(pubkey, config.size, `invalid payload size: ${pubkey.length} !== ${config.size}`);
     return encode_address({
-        data: bytes,
+        data: pubkey,
         format: 'bech32m',
         prefix: config.prefix
     });
 }
 function decode_p2tr_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
+function decode_p2tr_script(script) {
+    Assert.ok(is_p2tr_script(script), `invalid p2tr script`);
+    const bytes = Buff.bytes(script);
+    return bytes.slice(2, 34);
+}
 
-var AddressTool;
-(function (AddressTool) {
-    AddressTool.P2PKH = P2PKH;
-    AddressTool.P2SH = P2SH;
-    AddressTool.P2WPKH = P2WPKH;
-    AddressTool.P2WSH = P2WSH;
-    AddressTool.P2TR = P2TR;
-    AddressTool.parse = parse_address;
-})(AddressTool || (AddressTool = {}));
+function create_address(script, network = 'main') {
+    const bytes = Buff.bytes(script);
+    const type = get_lock_script_type(bytes);
+    if (type === null)
+        throw new Error('unrecognized script type: ' + bytes.hex);
+    switch (type) {
+        case LOCK_SCRIPT_TYPE.P2PKH:
+            return P2PKH.create_address(script, network);
+        case LOCK_SCRIPT_TYPE.P2SH:
+            return P2SH.create_address(script, network);
+        case LOCK_SCRIPT_TYPE.P2WPKH:
+            return P2WPKH.create_address(script, network);
+        case LOCK_SCRIPT_TYPE.P2WSH:
+            return P2WSH.create_address(script, network);
+        case LOCK_SCRIPT_TYPE.P2TR:
+            return P2TR.create_address(script, network);
+        default:
+            throw new Error('unrecognized script type: ' + type);
+    }
+}
+function parse_address(address) {
+    return get_address_info(address);
+}
 
 var index$8 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get AddressTool () { return AddressTool; },
     get P2PKH () { return P2PKH; },
     get P2SH () { return P2SH; },
     get P2TR () { return P2TR; },
     get P2WPKH () { return P2WPKH; },
     get P2WSH () { return P2WSH; },
+    create_address: create_address,
     parse_address: parse_address
 });
 
@@ -8858,6 +9072,13 @@ function get_size_varint(size) {
     }
 }
 
+function parse_script(script) {
+    const bytes = Buff.bytes(script);
+    return {
+        asm: decode_script(bytes),
+        hex: bytes.hex
+    };
+}
 function decode_script(script) {
     const stream = new Stream(script);
     const stack = [];
@@ -9196,12 +9417,10 @@ function parse_script_pubkeys(script) {
 
 var ScriptUtil;
 (function (ScriptUtil) {
-    ScriptUtil.prefix_size = prefix_script_size;
+    ScriptUtil.parse = parse_script;
     ScriptUtil.decode = decode_script;
     ScriptUtil.encode = encode_script;
     ScriptUtil.is_valid = is_valid_script;
-    ScriptUtil.get_pubkeys = parse_script_pubkeys;
-    ScriptUtil.OPCODES = OPCODE_MAP;
 })(ScriptUtil || (ScriptUtil = {}));
 
 var index$6 = /*#__PURE__*/Object.freeze({
@@ -9212,11 +9431,22 @@ var index$6 = /*#__PURE__*/Object.freeze({
     encode_script: encode_script,
     encode_script_word: encode_script_word,
     get_asm_code: get_asm_code,
+    get_lock_script_info: get_lock_script_info,
+    get_lock_script_type: get_lock_script_type,
+    get_lock_script_version: get_lock_script_version,
     get_op_code: get_op_code,
     get_op_type: get_op_type,
     get_size_varint: get_size_varint,
+    is_opreturn_script: is_opreturn_script,
+    is_p2pkh_script: is_p2pkh_script,
+    is_p2sh_script: is_p2sh_script,
+    is_p2tr_script: is_p2tr_script,
+    is_p2wpkh_script: is_p2wpkh_script,
+    is_p2wsh_script: is_p2wsh_script,
+    is_return_script: is_return_script,
     is_valid_op: is_valid_op,
     is_valid_script: is_valid_script,
+    parse_script: parse_script,
     parse_script_pubkeys: parse_script_pubkeys,
     prefix_script_size: prefix_script_size,
     prefix_word_size: prefix_word_size,
@@ -9251,57 +9481,6 @@ function get_annex_data(witness) {
     return undefined;
 }
 
-const COINBASE = {
-    TXID: '00'.repeat(32),
-    VOUT: 0xFFFFFFFF,
-};
-const DEFAULT = {
-    LOCKTIME: 0,
-    SEQUENCE: 0xFFFFFFFF,
-    VERSION: 2,
-};
-const TAPLEAF_VERSIONS = [
-    0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
-    0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
-    0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
-    0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
-    0x66, 0x7e, 0x80, 0x84, 0x96, 0x98, 0xba, 0xbc,
-    0xbe
-];
-const TAPLEAF_DEFAULT_VERSION = 0xc0;
-const LOCK_SCRIPT_REGEX = {
-    'p2pkh': /^76a914[0-9a-f]{40}88ac$/i,
-    'p2sh': /^a914[0-9a-f]{40}87$/i,
-    'p2wpkh': /^0014[0-9a-f]{40}$/i,
-    'p2wsh': /^0020[0-9a-f]{64}$/i,
-    'p2tr': /^5120[0-9a-f]{64}$/i,
-    'opreturn': /^6a[0-9a-f]{2,}$/i,
-};
-const SCRIPT_INT_KEY = '';
-const TX_SIZE = {
-    GLOBAL_BASE: 8,
-    GLOBAL_WIT: 10,
-    TXIN_BASE: 32 + 4 + 4,
-    TXOUT_BASE: 8,
-};
-const SIGHASH_DEFAULT = 0x01;
-const SIGHASH_SEGWIT = [0x01, 0x02, 0x03, 0x81, 0x82, 0x83];
-const SIGHASH_TAPROOT = [0x00, ...SIGHASH_SEGWIT];
-
-var _const = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    COINBASE: COINBASE,
-    DEFAULT: DEFAULT,
-    LOCK_SCRIPT_REGEX: LOCK_SCRIPT_REGEX,
-    SCRIPT_INT_KEY: SCRIPT_INT_KEY,
-    SIGHASH_DEFAULT: SIGHASH_DEFAULT,
-    SIGHASH_SEGWIT: SIGHASH_SEGWIT,
-    SIGHASH_TAPROOT: SIGHASH_TAPROOT,
-    TAPLEAF_DEFAULT_VERSION: TAPLEAF_DEFAULT_VERSION,
-    TAPLEAF_VERSIONS: TAPLEAF_VERSIONS,
-    TX_SIZE: TX_SIZE
-});
-
 const taptree = union([array(byte32), byte32]);
 const config = object({
     pubkey: byte32,
@@ -9624,32 +9803,6 @@ function serialize_tx(txdata) {
     return { version, locktime, vin, vout };
 }
 
-function is_return_script(script) {
-    const bytes = Buff.bytes(script);
-    return bytes.at(0) === 0x6a;
-}
-function get_vout_script_info(script) {
-    return {
-        type: get_vout_script_type(script),
-        version: get_vout_script_version(script)
-    };
-}
-function get_vout_script_type(script) {
-    const hex = Buff.bytes(script).hex;
-    for (const [type, regex] of Object.entries(LOCK_SCRIPT_REGEX)) {
-        if (regex.test(hex))
-            return type;
-    }
-    return null;
-}
-function get_vout_script_version(script) {
-    const version = Buff.bytes(script);
-    switch (version.at(0)) {
-        case 0x00: return 0;
-        case 0x51: return 1;
-        default: return null;
-    }
-}
 function get_txid(txdata) {
     if (typeof txdata === 'object') {
         assert_tx_template(txdata);
@@ -9825,12 +9978,8 @@ var index$4 = /*#__PURE__*/Object.freeze({
     get_txout_size: get_txout_size,
     get_txsize: get_txsize,
     get_vin_size: get_vin_size,
-    get_vout_script_info: get_vout_script_info,
-    get_vout_script_type: get_vout_script_type,
-    get_vout_script_version: get_vout_script_version,
     get_vout_size: get_vout_size,
     get_vsize: get_vsize,
-    is_return_script: is_return_script,
     normalize_prevout: normalize_prevout,
     normalize_sequence: normalize_sequence,
     normalize_value: normalize_value,
@@ -10173,9 +10322,9 @@ function parse_cblock_data(data) {
 function parse_witness_script(elems, type) {
     let script;
     switch (type) {
-        case 'p2tr-ts':
+        case 'p2ts':
             script = elems.at(-1);
-        case 'p2w-sh':
+        case 'p2wsh':
             script = elems.at(-1);
     }
     return (script !== undefined) ? new Buff(script).hex : null;
@@ -10183,34 +10332,36 @@ function parse_witness_script(elems, type) {
 function parse_witness_type(elems, cblock) {
     let param_0 = elems.at(0), param_1 = elems.at(1), param_x = elems.at(-1);
     if (cblock !== null && param_x !== undefined) {
-        return 'p2tr-ts';
+        return 'p2ts';
     }
     else if (elems.length === 2 &&
         param_0 !== undefined &&
         param_1 !== undefined &&
         param_0.length >= 64 &&
         param_1.length === 33) {
-        return 'p2w-pkh';
+        return 'p2wpkh';
     }
     else if (elems.length === 1 &&
         param_0 !== undefined &&
         param_0.length === 64) {
-        return 'p2tr-pk';
+        return 'p2tr';
     }
     else if (elems.length > 1 &&
         param_x !== undefined &&
         is_valid_script(param_x)) {
-        return 'p2w-sh';
+        return 'p2wsh';
     }
     else {
-        return 'unknown';
+        return null;
     }
 }
 function parse_witness_version(type) {
-    if (type.startsWith('p2tr'))
-        return 1;
+    if (type === null)
+        return null;
     if (type.startsWith('p2w'))
         return 0;
+    if (type.startsWith('p2t'))
+        return 1;
     return null;
 }