@vbyte/btc-dev 1.1.3 → 1.1.4

package/dist/const.d.ts

@@ -9,6 +9,22 @@ export declare const DEFAULT: {
 };
 export declare const TAPLEAF_VERSIONS: number[];
 export declare const TAPLEAF_DEFAULT_VERSION = 192;
+export declare const LOCK_SCRIPT_TYPE: {
+    readonly P2PKH: "p2pkh";
+    readonly P2SH: "p2sh";
+    readonly P2WPKH: "p2wpkh";
+    readonly P2WSH: "p2wsh";
+    readonly P2TR: "p2tr";
+    readonly OPRETURN: "opreturn";
+};
+export declare const SPEND_SCRIPT_TYPE: {
+    readonly P2PKH: "p2pkh";
+    readonly P2SH: "p2sh";
+    readonly P2WPKH: "p2wpkh";
+    readonly P2WSH: "p2wsh";
+    readonly P2TR: "p2tr";
+    readonly P2TS: "p2ts";
+};
 export declare const LOCK_SCRIPT_REGEX: Record<string, RegExp>;
 export declare const SCRIPT_INT_KEY = "";
 export declare const TX_SIZE: {

package/dist/const.js

@@ -16,13 +16,29 @@ export const TAPLEAF_VERSIONS = [
     0xbe
 ];
 export const TAPLEAF_DEFAULT_VERSION = 0xc0;
+export const LOCK_SCRIPT_TYPE = {
+    P2PKH: 'p2pkh',
+    P2SH: 'p2sh',
+    P2WPKH: 'p2wpkh',
+    P2WSH: 'p2wsh',
+    P2TR: 'p2tr',
+    OPRETURN: 'opreturn',
+};
+export const SPEND_SCRIPT_TYPE = {
+    P2PKH: 'p2pkh',
+    P2SH: 'p2sh',
+    P2WPKH: 'p2wpkh',
+    P2WSH: 'p2wsh',
+    P2TR: 'p2tr',
+    P2TS: 'p2ts',
+};
 export 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,
+    [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,
 };
 export const SCRIPT_INT_KEY = '';
 export const TX_SIZE = {

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

@@ -0,0 +1,4 @@
+import { Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+export declare function create_address(script: Bytes, network?: ChainNetwork): string;
+export declare function parse_address(address: string): AddressInfo;

package/dist/lib/address/api.js

@@ -0,0 +1,32 @@
+import { Buff } from '@vbyte/buff';
+import { get_lock_script_type } from '../../lib/script/lock.js';
+import { get_address_info } from './util.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { P2PKH } from './p2pkh.js';
+import { P2SH } from './p2sh.js';
+import { P2TR } from './p2tr.js';
+import { P2WPKH } from './p2wpkh.js';
+import { P2WSH } from './p2wsh.js';
+export 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);
+    }
+}
+export function parse_address(address) {
+    return get_address_info(address);
+}

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

@@ -1,3 +1,3 @@
-import type { DecodedAddress } from '../../types/address.js';
-export declare function decode_address(address: string): DecodedAddress;
-export declare function encode_address(config: DecodedAddress): string;
+import type { EncoderConfig } from '../../types/address.js';
+export declare function decode_address(address: string): EncoderConfig;
+export declare function encode_address(config: EncoderConfig): string;

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

@@ -1,20 +1,6 @@
-import { P2PKH as P2PKH_TOOL } from './p2pkh.js';
-import { P2SH as P2SH_TOOL } from './p2sh.js';
-import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js';
-import { P2WSH as P2WSH_TOOL } from './p2wsh.js';
-import { P2TR as P2TR_TOOL } from './p2tr.js';
-import { parse_address } from './util.js';
 export { P2PKH } from './p2pkh.js';
 export { P2SH } from './p2sh.js';
 export { P2WPKH } from './p2wpkh.js';
 export { P2WSH } from './p2wsh.js';
 export { P2TR } from './p2tr.js';
-export { parse_address } from './util.js';
-export declare namespace AddressTool {
-    const P2PKH: typeof P2PKH_TOOL;
-    const P2SH: typeof P2SH_TOOL;
-    const P2WPKH: typeof P2WPKH_TOOL;
-    const P2WSH: typeof P2WSH_TOOL;
-    const P2TR: typeof P2TR_TOOL;
-    const parse: typeof parse_address;
-}
+export * from './api.js';

package/dist/lib/address/index.js

@@ -1,21 +1,6 @@
-import { P2PKH as P2PKH_TOOL } from './p2pkh.js';
-import { P2SH as P2SH_TOOL } from './p2sh.js';
-import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js';
-import { P2WSH as P2WSH_TOOL } from './p2wsh.js';
-import { P2TR as P2TR_TOOL } from './p2tr.js';
-import { parse_address } from './util.js';
 export { P2PKH } from './p2pkh.js';
 export { P2SH } from './p2sh.js';
 export { P2WPKH } from './p2wpkh.js';
 export { P2WSH } from './p2wsh.js';
 export { P2TR } from './p2tr.js';
-export { parse_address } from './util.js';
-export var AddressTool;
-(function (AddressTool) {
-    AddressTool.P2PKH = P2PKH_TOOL;
-    AddressTool.P2SH = P2SH_TOOL;
-    AddressTool.P2WPKH = P2WPKH_TOOL;
-    AddressTool.P2WSH = P2WSH_TOOL;
-    AddressTool.P2TR = P2TR_TOOL;
-    AddressTool.parse = parse_address;
-})(AddressTool || (AddressTool = {}));
+export * from './api.js';

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

@@ -1,10 +1,17 @@
-import type { AddressData, ChainNetwork } from '../../types/index.js';
+import { Buff, Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
 export declare namespace P2PKH {
-    const create: typeof create_p2pkh_address;
-    const encode: typeof encode_p2pkh_address;
-    const decode: typeof decode_p2pkh_address;
+    const create_address: typeof create_p2pkh_address;
+    const create_script: typeof create_p2pkh_script;
+    const encode_address: typeof encode_p2pkh_address;
+    const encode_script: typeof encode_p2pkh_script;
+    const decode_address: typeof decode_p2pkh_address;
+    const decode_script: typeof decode_p2pkh_script;
 }
-declare function create_p2pkh_address(script: string | Uint8Array, network?: ChainNetwork): string;
-declare function encode_p2pkh_address(pk_hash: string | Uint8Array, network?: ChainNetwork): string;
-declare function decode_p2pkh_address(address: string): AddressData;
+declare function create_p2pkh_address(pubkey: Bytes, network?: ChainNetwork): string;
+declare function create_p2pkh_script(pubkey: Bytes): Buff;
+declare function encode_p2pkh_script(pk_hash: Bytes): Buff;
+declare function encode_p2pkh_address(script: Bytes, network?: ChainNetwork): string;
+declare function decode_p2pkh_address(address: string): AddressInfo;
+declare function decode_p2pkh_script(script: Bytes): Buff;
 export {};

package/dist/lib/address/p2pkh.js

@@ -2,32 +2,50 @@ import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { hash160 } from '@vbyte/micro-lib/hash';
 import { encode_address } from './encode.js';
-import { get_address_config, parse_address } from './util.js';
-const ADDR_TYPE = 'p2pkh';
+import { is_p2pkh_script } from '../../lib/script/lock.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { get_address_config, get_address_info } from './util.js';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2PKH;
 export 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);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} 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);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} 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}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     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);
+}

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

@@ -1,10 +1,17 @@
-import type { ChainNetwork, AddressData } from '../../types/index.js';
+import { Buff, Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
 export declare namespace P2SH {
-    const create: typeof create_p2sh_address;
-    const encode: typeof encode_p2sh_address;
-    const decode: typeof decode_p2sh_address;
+    const create_address: typeof create_p2sh_address;
+    const create_script: typeof create_p2sh_script;
+    const encode_address: typeof encode_p2sh_address;
+    const encode_script: typeof encode_p2sh_script;
+    const decode_address: typeof decode_p2sh_address;
+    const decode_script: typeof decode_p2sh_script;
 }
-declare function create_p2sh_address(script: string | Uint8Array, network?: ChainNetwork): string;
-declare function encode_p2sh_address(script_hash: string | Uint8Array, network?: ChainNetwork): string;
-declare function decode_p2sh_address(address: string): AddressData;
+declare function create_p2sh_address(script: Bytes, network?: ChainNetwork): string;
+declare function create_p2sh_script(script: Bytes): Buff;
+declare function encode_p2sh_script(script_hash: Bytes): Buff;
+declare function encode_p2sh_address(script_pk: Bytes, network?: ChainNetwork): string;
+declare function decode_p2sh_address(address: string): AddressInfo;
+declare function decode_p2sh_script(script: Bytes): Buff;
 export {};

package/dist/lib/address/p2sh.js

@@ -2,32 +2,51 @@ import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { hash160 } from '@vbyte/micro-lib/hash';
 import { encode_address } from './encode.js';
-import { get_address_config, parse_address } from './util.js';
-const ADDR_TYPE = 'p2sh';
+import { is_p2sh_script } from '../../lib/script/lock.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { get_address_config, get_address_info } from './util.js';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2SH;
 export 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 encode_p2sh_address(script_hash, network = 'main') {
-    const bytes = Buff.bytes(script_hash);
-    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}`);
+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_pk, network = 'main') {
+    const script_hash = decode_p2sh_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} 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}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     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);
+}

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

@@ -1,8 +1,17 @@
-import type { ChainNetwork, AddressData } from '../../types/index.js';
+import { Buff, Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
 export declare namespace P2TR {
-    const encode: typeof encode_p2tr_address;
-    const decode: typeof decode_p2tr_address;
+    const create_address: typeof create_p2tr_address;
+    const create_script: typeof create_p2tr_script;
+    const encode_address: typeof encode_p2tr_address;
+    const encode_script: typeof encode_p2tr_script;
+    const decode_address: typeof decode_p2tr_address;
+    const decode_script: typeof decode_p2tr_script;
 }
-declare function encode_p2tr_address(pubkey: string | Uint8Array, network?: ChainNetwork): string;
-declare function decode_p2tr_address(address: string): AddressData;
+declare function create_p2tr_address(pubkey: Bytes, network?: ChainNetwork): string;
+declare function create_p2tr_script(pubkey: Bytes): Buff;
+declare function encode_p2tr_script(pubkey: Bytes): Buff;
+declare function encode_p2tr_address(script_pk: Bytes, network?: ChainNetwork): string;
+declare function decode_p2tr_address(address: string): AddressInfo;
+declare function decode_p2tr_script(script: Bytes): Buff;
 export {};

package/dist/lib/address/p2tr.js

@@ -1,26 +1,49 @@
 import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { encode_address } from './encode.js';
-import { get_address_config, parse_address } from './util.js';
-const ADDR_TYPE = 'p2tr';
+import { is_p2tr_script } from '../../lib/script/lock.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { get_address_config, get_address_info } from './util.js';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2TR;
 export 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);
+}

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

@@ -1,10 +1,17 @@
-import type { AddressData, ChainNetwork } from '../../types/index.js';
+import { Buff, Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
 export declare namespace P2WPKH {
-    const create: typeof create_p2wpkh_address;
-    const encode: typeof encode_p2wpkh_address;
-    const decode: typeof decode_p2wpkh_address;
+    const create_address: typeof create_p2wpkh_address;
+    const create_script: typeof create_p2wpkh_script;
+    const encode_address: typeof encode_p2wpkh_address;
+    const encode_script: typeof encode_p2wpkh_script;
+    const decode_address: typeof decode_p2wpkh_address;
+    const decode_script: typeof decode_p2wpkh_script;
 }
-declare function create_p2wpkh_address(pubkey: string | Uint8Array, network?: ChainNetwork): string;
-declare function encode_p2wpkh_address(pk_hash: string | Uint8Array, network?: ChainNetwork): string;
-declare function decode_p2wpkh_address(address: string): AddressData;
+declare function create_p2wpkh_address(pubkey: Bytes, network?: ChainNetwork): string;
+declare function create_p2wpkh_script(pubkey: Bytes): Buff;
+declare function encode_p2wpkh_script(pk_hash: Bytes): Buff;
+declare function encode_p2wpkh_address(script_pk: Bytes, network?: ChainNetwork): string;
+declare function decode_p2wpkh_address(address: string): AddressInfo;
+declare function decode_p2wpkh_script(script: Bytes): Buff;
 export {};

package/dist/lib/address/p2wpkh.js

@@ -2,33 +2,50 @@ import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { hash160 } from '@vbyte/micro-lib/hash';
 import { encode_address } from './encode.js';
-import { get_address_config, parse_address } from './util.js';
-const ADDR_TYPE = 'p2w-pkh';
+import { is_p2wpkh_script } from '../../lib/script/lock.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { get_address_config, get_address_info } from './util.js';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WPKH;
 export 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_script(pk_hash) {
+    return Buff.join(['0014', pk_hash]);
 }
-function encode_p2wpkh_address(pk_hash, network = 'main') {
-    const bytes = Buff.bytes(pk_hash);
-    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}`);
+function encode_p2wpkh_address(script_pk, network = 'main') {
+    const pk_hash = decode_p2wpkh_script(script_pk);
+    const config = get_address_config(network, ADDRESS_TYPE);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} 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}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2wpkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     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);
+}

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

@@ -1,10 +1,17 @@
-import type { ChainNetwork, AddressData } from '../../types/index.js';
+import { Buff, Bytes } from '@vbyte/buff';
+import type { AddressInfo, ChainNetwork } from '../../types/index.js';
 export declare namespace P2WSH {
-    const create: typeof create_p2wsh_address;
-    const encode: typeof encode_p2wsh_address;
-    const decode: typeof decode_p2wsh_address;
+    const create_address: typeof create_p2wsh_address;
+    const create_script: typeof create_p2wsh_script;
+    const encode_address: typeof encode_p2wsh_address;
+    const encode_script: typeof encode_p2wsh_script;
+    const decode_address: typeof decode_p2wsh_address;
+    const decode_script: typeof decode_p2wsh_script;
 }
-declare function create_p2wsh_address(script: string | Uint8Array, network?: ChainNetwork): string;
-declare function encode_p2wsh_address(script_hash: string | Uint8Array, network?: ChainNetwork): string;
-declare function decode_p2wsh_address(address: string): AddressData;
+declare function create_p2wsh_address(script: Bytes, network?: ChainNetwork): string;
+declare function create_p2wsh_script(script: Bytes): Buff;
+declare function encode_p2wsh_script(script_hash: Bytes): Buff;
+declare function encode_p2wsh_address(script_pk: Bytes, network?: ChainNetwork): string;
+declare function decode_p2wsh_address(address: string): AddressInfo;
+declare function decode_p2wsh_script(script: Bytes): Buff;
 export {};

package/dist/lib/address/p2wsh.js

@@ -2,32 +2,49 @@ import { Buff } from '@vbyte/buff';
 import { Assert } from '@vbyte/micro-lib';
 import { sha256 } from '@vbyte/micro-lib/hash';
 import { encode_address } from './encode.js';
-import { get_address_config, parse_address } from './util.js';
-const ADDR_TYPE = 'p2w-sh';
+import { is_p2wsh_script } from '../../lib/script/lock.js';
+import { LOCK_SCRIPT_TYPE } from '../../const.js';
+import { get_address_config, get_address_info } from './util.js';
+const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WSH;
 export 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);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} 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);
+    Assert.exists(config, `unrecognized address config: ${ADDRESS_TYPE} 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}`);
+    const parsed = get_address_info(address);
+    Assert.ok(parsed.type === 'p2wsh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     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);
+}

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

@@ -1,5 +1,2 @@
-import type { AddressType } from '../../types/index.js';
-export declare function get_address_script(script_key: string, script_type: AddressType): {
-    script_hex: string;
-    script_asm: string[];
-};
+import type { AddressType, ScriptInfo } from '../../types/index.js';
+export declare function get_address_script(script_key: string, script_type: AddressType): ScriptInfo;