@vbyte/btc-dev 1.1.3 → 1.1.5

package/dist/lib/address/script.js

@@ -4,9 +4,9 @@ export function get_address_script(script_key, script_type) {
             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);
@@ -16,31 +16,31 @@ export 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]
     };
 }

package/dist/lib/address/util.d.ts

@@ -1,4 +1,3 @@
-import type { AddressConfig, AddressType, ChainNetwork, AddressContext, AddressData } from '../../types/index.js';
-export declare function get_address_config(address_network: ChainNetwork, address_type: AddressType): AddressConfig | null;
-export declare function get_address_ctx(address: string): AddressContext;
-export declare function parse_address(address: string): AddressData;
+import type { AddressConfig, AddressInfo, ChainNetwork, LockScriptType } from '../../types/index.js';
+export declare function get_address_config(address_network: ChainNetwork, address_type: LockScriptType): AddressConfig | null;
+export declare function get_address_info(address: string): AddressInfo;

package/dist/lib/address/util.js

@@ -10,12 +10,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]
@@ -28,7 +28,7 @@ export function get_address_config(address_network, address_type) {
     }
     return null;
 }
-export function get_address_ctx(address) {
+export 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)
@@ -45,13 +45,9 @@ export 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');
 }
-export function parse_address(address) {
-    const ctx = get_address_ctx(address);
-    const script = get_address_script(ctx.hex, ctx.type);
-    return { ...ctx, ...script };
-}

package/dist/lib/script/decode.d.ts

@@ -1,3 +1,5 @@
 import { Bytes } from '@vbyte/buff';
+import type { ScriptInfo } from '../../types/script.js';
+export declare function parse_script(script: Bytes): ScriptInfo;
 export declare function decode_script(script: Bytes): string[];
 export declare function is_valid_script(script: string | Uint8Array): boolean;

package/dist/lib/script/decode.js

@@ -1,5 +1,12 @@
-import { Stream } from '@vbyte/buff';
+import { Buff, Stream } from '@vbyte/buff';
 import { get_op_code, get_op_type, is_valid_op } from './words.js';
+export function parse_script(script) {
+    const bytes = Buff.bytes(script);
+    return {
+        asm: decode_script(bytes),
+        hex: bytes.hex
+    };
+}
 export function decode_script(script) {
     const stream = new Stream(script);
     const stack = [];

package/dist/lib/script/index.d.ts

@@ -1,126 +1,13 @@
 import { encode_script } from './encode.js';
-import { decode_script, is_valid_script } from './decode.js';
-import { parse_script_pubkeys, prefix_script_size } from './util.js';
+import { decode_script, is_valid_script, parse_script } from './decode.js';
 export * from './decode.js';
 export * from './encode.js';
+export * from './lock.js';
 export * from './util.js';
 export * from './words.js';
 export declare namespace ScriptUtil {
-    const prefix_size: typeof prefix_script_size;
+    const parse: typeof parse_script;
     const decode: typeof decode_script;
     const encode: typeof encode_script;
     const is_valid: typeof is_valid_script;
-    const get_pubkeys: typeof parse_script_pubkeys;
-    const OPCODES: {
-        OP_0: number;
-        OP_PUSHDATA1: number;
-        OP_PUSHDATA2: number;
-        OP_PUSHDATA4: number;
-        OP_1NEGATE: number;
-        OP_SUCCESS80: number;
-        OP_1: number;
-        OP_2: number;
-        OP_3: number;
-        OP_4: number;
-        OP_5: number;
-        OP_6: number;
-        OP_7: number;
-        OP_8: number;
-        OP_9: number;
-        OP_10: number;
-        OP_11: number;
-        OP_12: number;
-        OP_13: number;
-        OP_14: number;
-        OP_15: number;
-        OP_16: number;
-        OP_NOP: number;
-        OP_SUCCESS98: number;
-        OP_IF: number;
-        OP_NOTIF: number;
-        OP_ELSE: number;
-        OP_ENDIF: number;
-        OP_VERIFY: number;
-        OP_RETURN: number;
-        OP_TOALTSTACK: number;
-        OP_FROMALTSTACK: number;
-        OP_2DROP: number;
-        OP_2DUP: number;
-        OP_3DUP: number;
-        OP_2OVER: number;
-        OP_2ROT: number;
-        OP_2SWAP: number;
-        OP_IFDUP: number;
-        OP_DEPTH: number;
-        OP_DROP: number;
-        OP_DUP: number;
-        OP_NIP: number;
-        OP_OVER: number;
-        OP_PICK: number;
-        OP_ROLL: number;
-        OP_ROT: number;
-        OP_SWAP: number;
-        OP_TUCK: number;
-        OP_SUCCESS126: number;
-        OP_SUCCESS127: number;
-        OP_SUCCESS128: number;
-        OP_SUCCESS129: number;
-        OP_SIZE: number;
-        OP_SUCCESS131: number;
-        OP_SUCCESS132: number;
-        OP_SUCCESS133: number;
-        OP_SUCCESS134: number;
-        OP_EQUAL: number;
-        OP_EQUALVERIFY: number;
-        OP_SUCCESS137: number;
-        OP_SUCCESS138: number;
-        OP_1ADD: number;
-        OP_1SUB: number;
-        OP_SUCCESS141: number;
-        OP_SUCCESS142: number;
-        OP_NEGATE: number;
-        OP_ABS: number;
-        OP_NOT: number;
-        OP_0NOTEQUAL: number;
-        OP_ADD: number;
-        OP_SUB: number;
-        OP_SUCCESS149: number;
-        OP_SUCCESS150: number;
-        OP_SUCCESS151: number;
-        OP_SUCCESS152: number;
-        OP_SUCCESS153: number;
-        OP_BOOLAND: number;
-        OP_BOOLOR: number;
-        OP_NUMEQUAL: number;
-        OP_NUMEQUALVERIFY: number;
-        OP_NUMNOTEQUAL: number;
-        OP_LESSTHAN: number;
-        OP_GREATERTHAN: number;
-        OP_LESSTHANOREQUAL: number;
-        OP_GREATERTHANOREQUAL: number;
-        OP_MIN: number;
-        OP_MAX: number;
-        OP_WITHIN: number;
-        OP_RIPEMD160: number;
-        OP_SHA1: number;
-        OP_SHA256: number;
-        OP_HASH160: number;
-        OP_HASH256: number;
-        OP_CODESEPARATOR: number;
-        OP_CHECKSIG: number;
-        OP_CHECKSIGVERIFY: number;
-        OP_CHECKMULTISIG: number;
-        OP_CHECKMULTISIGVERIFY: number;
-        OP_NOP1: number;
-        OP_CHECKLOCKTIMEVERIFY: number;
-        OP_CHECKSEQUENCEVERIFY: number;
-        OP_NOP4: number;
-        OP_NOP5: number;
-        OP_NOP6: number;
-        OP_NOP7: number;
-        OP_NOP8: number;
-        OP_NOP9: number;
-        OP_NOP10: number;
-        OP_CHECKSIGADD: number;
-    };
 }

package/dist/lib/script/index.js

@@ -1,17 +1,14 @@
-import { OPCODE_MAP } from './words.js';
 import { encode_script } from './encode.js';
-import { decode_script, is_valid_script } from './decode.js';
-import { parse_script_pubkeys, prefix_script_size } from './util.js';
+import { decode_script, is_valid_script, parse_script } from './decode.js';
 export * from './decode.js';
 export * from './encode.js';
+export * from './lock.js';
 export * from './util.js';
 export * from './words.js';
 export 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 = {}));

package/dist/lib/script/lock.d.ts

@@ -0,0 +1,12 @@
+import { Bytes } from '@vbyte/buff';
+import type { LockScriptInfo, LockScriptType, WitnessVersion } from '../../types/index.js';
+export declare function is_return_script(script: Bytes): boolean;
+export declare function get_lock_script_info(script: Bytes): LockScriptInfo;
+export declare function get_lock_script_type(script: Bytes): LockScriptType | null;
+export declare function get_lock_script_version(script: Bytes): WitnessVersion | null;
+export declare function is_p2pkh_script(script: Bytes): boolean;
+export declare function is_p2sh_script(script: Bytes): boolean;
+export declare function is_p2wpkh_script(script: Bytes): boolean;
+export declare function is_p2wsh_script(script: Bytes): boolean;
+export declare function is_p2tr_script(script: Bytes): boolean;
+export declare function is_opreturn_script(script: Bytes): boolean;

package/dist/lib/script/lock.js

@@ -0,0 +1,52 @@
+import { Buff } from '@vbyte/buff';
+import { LOCK_SCRIPT_REGEX } from '../../const.js';
+export function is_return_script(script) {
+    const bytes = Buff.bytes(script);
+    return bytes.at(0) === 0x6a;
+}
+export function get_lock_script_info(script) {
+    return {
+        type: get_lock_script_type(script),
+        version: get_lock_script_version(script)
+    };
+}
+export 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;
+}
+export 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;
+    }
+}
+export function is_p2pkh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2pkh'].test(hex);
+}
+export function is_p2sh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2sh'].test(hex);
+}
+export function is_p2wpkh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2wpkh'].test(hex);
+}
+export function is_p2wsh_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2wsh'].test(hex);
+}
+export function is_p2tr_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['p2tr'].test(hex);
+}
+export function is_opreturn_script(script) {
+    const hex = Buff.bytes(script).hex;
+    return LOCK_SCRIPT_REGEX['opreturn'].test(hex);
+}

package/dist/lib/tx/util.d.ts

@@ -1,9 +1,4 @@
-import { Bytes } from '@vbyte/buff';
-import type { TxData, TxOutput, TxOutputInfo, TxOutputTemplate, TxOutputType, TxValue, WitnessVersion } from '../../types/index.js';
-export declare function is_return_script(script: Bytes): boolean;
-export declare function get_vout_script_info(script: Bytes): TxOutputInfo;
-export declare function get_vout_script_type(script: Bytes): TxOutputType | null;
-export declare function get_vout_script_version(script: Bytes): WitnessVersion | null;
+import type { TxData, TxOutput, TxOutputTemplate, TxValue } from '../../types/index.js';
 export declare function get_txid(txdata: string | Uint8Array | TxData): string;
 export declare function get_txhash(txdata: string | Uint8Array | TxData): string;
 export declare function get_tx_value(txdata: string | Uint8Array | TxData): TxValue;

package/dist/lib/tx/util.js

@@ -5,33 +5,7 @@ import { hash256 } from '@vbyte/micro-lib/hash';
 import { encode_tx } from './encode.js';
 import { parse_tx } from './parse.js';
 import { assert_tx_template } from './validate.js';
-import { DEFAULT, LOCK_SCRIPT_REGEX } from '../../const.js';
-export function is_return_script(script) {
-    const bytes = Buff.bytes(script);
-    return bytes.at(0) === 0x6a;
-}
-export function get_vout_script_info(script) {
-    return {
-        type: get_vout_script_type(script),
-        version: get_vout_script_version(script)
-    };
-}
-export 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;
-}
-export 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;
-    }
-}
+import { DEFAULT } from '../../const.js';
 export function get_txid(txdata) {
     if (typeof txdata === 'object') {
         assert_tx_template(txdata);

package/dist/lib/witness/parse.js

@@ -44,9 +44,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;
@@ -54,33 +54,35 @@ 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;
 }