@vbyte/btc-dev 1.1.8 → 2.1.0

package/dist/lib/address/encode.js

@@ -1,34 +1,36 @@
-import { Buff } from '@vbyte/buff';
-import { Assert, B58chk, Bech32, Bech32m } from '@vbyte/micro-lib';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { B58chk, Bech32, Bech32m } from "@vbyte/crypto";
+import { ValidationError } from "../../error.js";
 const ENCODING_REGEX = {
     base58: /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
     bech32: /^(bc|tb|bcrt)1q[ac-hj-np-z02-9]{6,87}$/,
-    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/
+    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/,
 };
 const VERSION = {
     bech32: 0,
-    bech32m: 1
+    bech32m: 1,
 };
 export function decode_address(address) {
     const format = get_address_format(address);
     if (format === null)
-        throw new Error('unrecognized address format: ' + format);
-    if (format === 'base58')
+        throw new ValidationError(`unrecognized address format: ${address}`, "address");
+    if (format === "base58")
         return base58_decode(address);
-    if (format === 'bech32')
+    if (format === "bech32")
         return bech32_decode(address);
-    if (format === 'bech32m')
+    if (format === "bech32m")
         return bech32m_decode(address);
-    throw new Error('unable to find a matching address configuration');
+    throw new ValidationError("unable to find a matching address configuration", "address");
 }
 export function encode_address(config) {
-    if (config.format === 'base58')
+    if (config.format === "base58")
         return base58_encode(config);
-    if (config.format === 'bech32')
+    if (config.format === "bech32")
         return bech32_encode(config);
-    if (config.format === 'bech32m')
+    if (config.format === "bech32m")
         return bech32m_encode(config);
-    throw new Error('unrecognized encoding format: ' + config.format);
+    throw new ValidationError(`unrecognized encoding format: ${config.format}`, "format");
 }
 function get_address_format(address) {
     for (const [format, regex] of Object.entries(ENCODING_REGEX)) {
@@ -38,8 +40,8 @@ function get_address_format(address) {
     return null;
 }
 function base58_encode(config) {
-    Assert.ok(config.format === 'base58', 'encoding mismatch');
-    Assert.exists(config.version, 'must specify a version');
+    Assert.ok(config.format === "base58", "encoding mismatch");
+    Assert.exists(config.version, "must specify a version");
     const bytes = Buff.join([config.version, config.data]);
     return B58chk.encode(bytes);
 }
@@ -47,11 +49,11 @@ function base58_decode(encoded) {
     const bytes = B58chk.decode(encoded);
     const data = bytes.slice(1);
     const version = bytes[0];
-    return { data, format: 'base58', version };
+    return { data, format: "base58", version };
 }
 function bech32_encode(config) {
-    Assert.ok(config.format === 'bech32', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
+    Assert.ok(config.format === "bech32", "encoding mismatch");
+    Assert.exists(config.prefix, "prefix is required");
     const bytes = Buff.bytes(config.data);
     const words = Bech32.to_words(bytes);
     return Bech32.encode(config.prefix, [VERSION.bech32, ...words]);
@@ -59,13 +61,13 @@ function bech32_encode(config) {
 function bech32_decode(encoded) {
     const { prefix, words } = Bech32.decode(encoded);
     const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32, 'bech32 version mismatch');
+    Assert.ok(version === VERSION.bech32, "bech32 version mismatch");
     const data = Bech32.to_bytes(rest);
-    return { data, format: 'bech32', prefix, version };
+    return { data, format: "bech32", prefix, version };
 }
 function bech32m_encode(config) {
-    Assert.ok(config.format === 'bech32m', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
+    Assert.ok(config.format === "bech32m", "encoding mismatch");
+    Assert.exists(config.prefix, "prefix is required");
     const bytes = Buff.bytes(config.data);
     const words = Bech32m.to_words(bytes);
     return Bech32m.encode(config.prefix, [VERSION.bech32m, ...words]);
@@ -73,7 +75,7 @@ function bech32m_encode(config) {
 function bech32m_decode(encoded) {
     const { prefix, words } = Bech32m.decode(encoded);
     const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32m, 'bech32m version mismatch');
+    Assert.ok(version === VERSION.bech32m, "bech32m version mismatch");
     const data = Bech32m.to_bytes(rest);
-    return { data, format: 'bech32m', prefix, version };
+    return { data, format: "bech32m", prefix, version };
 }

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

@@ -1,6 +1,6 @@
-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 * from './api.js';
+export * from "./api.js";
+export { P2PKH } from "./p2pkh.js";
+export { P2SH } from "./p2sh.js";
+export { P2TR } from "./p2tr.js";
+export { P2WPKH } from "./p2wpkh.js";
+export { P2WSH } from "./p2wsh.js";

package/dist/lib/address/index.js

@@ -1,6 +1,6 @@
-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 * from './api.js';
+export * from "./api.js";
+export { P2PKH } from "./p2pkh.js";
+export { P2SH } from "./p2sh.js";
+export { P2TR } from "./p2tr.js";
+export { P2WPKH } from "./p2wpkh.js";
+export { P2WSH } from "./p2wsh.js";

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare namespace P2PKH {
     const create_address: typeof create_p2pkh_address;
     const create_script: typeof create_p2pkh_script;

package/dist/lib/address/p2pkh.js

@@ -1,10 +1,10 @@
-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 { 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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash160 } from "@vbyte/crypto/hash";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { is_p2pkh_script } from "../../lib/script/lock.js";
+import { encode_address } from "./encode.js";
+import { get_address_config, get_address_info } from "./util.js";
 const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2PKH;
 export var P2PKH;
 (function (P2PKH) {
@@ -15,33 +15,33 @@ export var P2PKH;
     P2PKH.decode_address = decode_p2pkh_address;
     P2PKH.decode_script = decode_p2pkh_script;
 })(P2PKH || (P2PKH = {}));
-function create_p2pkh_address(pubkey, network = 'main') {
+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');
+    Assert.ok(bytes.length === 33, "invalid pubkey size");
     const hash = hash160(bytes);
     return encode_p2pkh_script(hash);
 }
 function encode_p2pkh_script(pk_hash) {
-    return Buff.join(['76a914', pk_hash, '88ac']);
+    return Buff.join(["76a914", pk_hash, "88ac"]);
 }
-function encode_p2pkh_address(script, network = 'main') {
+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}`);
+    Assert.ok(pk_hash.length === config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
     return encode_address({
         data: pk_hash,
-        format: 'base58',
-        version: config.version
+        format: "base58",
+        version: config.version,
     });
 }
 function decode_p2pkh_address(address) {
     const parsed = get_address_info(address);
-    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
+    Assert.ok(parsed.type === "p2pkh", `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
 function decode_p2pkh_script(script) {

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare namespace P2SH {
     const create_address: typeof create_p2sh_address;
     const create_script: typeof create_p2sh_script;

package/dist/lib/address/p2sh.js

@@ -1,10 +1,10 @@
-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 { 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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash160 } from "@vbyte/crypto/hash";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { is_p2sh_script } from "../../lib/script/lock.js";
+import { encode_address } from "./encode.js";
+import { get_address_config, get_address_info } from "./util.js";
 const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2SH;
 export var P2SH;
 (function (P2SH) {
@@ -15,7 +15,7 @@ export var P2SH;
     P2SH.decode_address = decode_p2sh_address;
     P2SH.decode_script = decode_p2sh_script;
 })(P2SH || (P2SH = {}));
-function create_p2sh_address(script, network = 'main') {
+function create_p2sh_address(script, network = "main") {
     const bytes = Buff.bytes(script);
     const hash = hash160(bytes);
     const p2sh_script = encode_p2sh_script(hash);
@@ -27,22 +27,22 @@ function create_p2sh_script(script) {
     return encode_p2sh_script(hash);
 }
 function encode_p2sh_script(script_hash) {
-    return Buff.join(['a914', script_hash, '87']);
+    return Buff.join(["a914", script_hash, "87"]);
 }
-function encode_p2sh_address(script_pk, network = 'main') {
+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}`);
+    Assert.ok(script_hash.length === config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
     return encode_address({
         data: script_hash,
-        format: 'base58',
-        version: config.version
+        format: "base58",
+        version: config.version,
     });
 }
 function decode_p2sh_address(address) {
     const parsed = get_address_info(address);
-    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
+    Assert.ok(parsed.type === "p2sh", `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
 function decode_p2sh_script(script) {

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare namespace P2TR {
     const create_address: typeof create_p2tr_address;
     const create_script: typeof create_p2tr_script;

package/dist/lib/address/p2tr.js

@@ -1,9 +1,9 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { encode_address } from './encode.js';
-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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { is_p2tr_script } from "../../lib/script/lock.js";
+import { encode_address } from "./encode.js";
+import { get_address_config, get_address_info } from "./util.js";
 const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2TR;
 export var P2TR;
 (function (P2TR) {
@@ -14,32 +14,32 @@ export var P2TR;
     P2TR.decode_address = decode_p2tr_address;
     P2TR.decode_script = decode_p2tr_script;
 })(P2TR || (P2TR = {}));
-function create_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);
-    Assert.size(bytes, 32, 'invalid pubkey size');
+    Assert.ok(bytes.length === 32, "invalid pubkey size");
     return encode_p2tr_script(bytes);
 }
 function encode_p2tr_script(pubkey) {
-    return Buff.join(['5120', pubkey]);
+    return Buff.join(["5120", pubkey]);
 }
-function encode_p2tr_address(script_pk, network = 'main') {
+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}`);
+    Assert.ok(pubkey.length === config.size, `invalid payload size: ${pubkey.length} !== ${config.size}`);
     return encode_address({
         data: pubkey,
-        format: 'bech32m',
-        prefix: config.prefix
+        format: "bech32m",
+        prefix: config.prefix,
     });
 }
 function decode_p2tr_address(address) {
     const parsed = get_address_info(address);
-    Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
+    Assert.ok(parsed.type === "p2tr", `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
 function decode_p2tr_script(script) {

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare namespace P2WPKH {
     const create_address: typeof create_p2wpkh_address;
     const create_script: typeof create_p2wpkh_script;

package/dist/lib/address/p2wpkh.js

@@ -1,10 +1,10 @@
-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 { 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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash160 } from "@vbyte/crypto/hash";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { is_p2wpkh_script } from "../../lib/script/lock.js";
+import { encode_address } from "./encode.js";
+import { get_address_config, get_address_info } from "./util.js";
 const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WPKH;
 export var P2WPKH;
 (function (P2WPKH) {
@@ -15,33 +15,33 @@ export var P2WPKH;
     P2WPKH.decode_address = decode_p2wpkh_address;
     P2WPKH.decode_script = decode_p2wpkh_script;
 })(P2WPKH || (P2WPKH = {}));
-function create_p2wpkh_address(pubkey, network = 'main') {
+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 pubkey size');
+    Assert.ok(bytes.length === 33, "invalid pubkey size");
     const hash = hash160(bytes);
     return encode_p2wpkh_script(hash);
 }
 function encode_p2wpkh_script(pk_hash) {
-    return Buff.join(['0014', pk_hash]);
+    return Buff.join(["0014", pk_hash]);
 }
-function encode_p2wpkh_address(script_pk, network = 'main') {
+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}`);
+    Assert.ok(pk_hash.length === config.size, `invalid payload size: ${pk_hash.length} !== ${config.size}`);
     return encode_address({
         data: pk_hash,
-        format: 'bech32',
-        prefix: config.prefix
+        format: "bech32",
+        prefix: config.prefix,
     });
 }
 function decode_p2wpkh_address(address) {
     const parsed = get_address_info(address);
-    Assert.ok(parsed.type === 'p2wpkh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
+    Assert.ok(parsed.type === "p2wpkh", `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
 function decode_p2wpkh_script(script) {

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { AddressInfo, ChainNetwork } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { AddressInfo, ChainNetwork } from "../../types/index.js";
 export declare namespace P2WSH {
     const create_address: typeof create_p2wsh_address;
     const create_script: typeof create_p2wsh_script;

package/dist/lib/address/p2wsh.js

@@ -1,10 +1,10 @@
-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 { 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';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { sha256 } from "@vbyte/crypto/hash";
+import { LOCK_SCRIPT_TYPE } from "../../const.js";
+import { is_p2wsh_script } from "../../lib/script/lock.js";
+import { encode_address } from "./encode.js";
+import { get_address_config, get_address_info } from "./util.js";
 const ADDRESS_TYPE = LOCK_SCRIPT_TYPE.P2WSH;
 export var P2WSH;
 (function (P2WSH) {
@@ -15,7 +15,7 @@ export var P2WSH;
     P2WSH.decode_address = decode_p2wsh_address;
     P2WSH.decode_script = decode_p2wsh_script;
 })(P2WSH || (P2WSH = {}));
-function create_p2wsh_address(script, network = 'main') {
+function create_p2wsh_address(script, network = "main") {
     const wsh_script = create_p2wsh_script(script);
     return encode_p2wsh_address(wsh_script, network);
 }
@@ -25,22 +25,22 @@ function create_p2wsh_script(script) {
     return encode_p2wsh_script(hash);
 }
 function encode_p2wsh_script(script_hash) {
-    return Buff.join(['0020', script_hash]);
+    return Buff.join(["0020", script_hash]);
 }
-function encode_p2wsh_address(script_pk, network = 'main') {
+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}`);
+    Assert.ok(script_hash.length === config.size, `invalid payload size: ${script_hash.length} !== ${config.size}`);
     return encode_address({
         data: script_hash,
-        format: 'bech32',
-        prefix: config.prefix
+        format: "bech32",
+        prefix: config.prefix,
     });
 }
 function decode_p2wsh_address(address) {
     const parsed = get_address_info(address);
-    Assert.ok(parsed.type === 'p2wsh', `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
+    Assert.ok(parsed.type === "p2wsh", `address type mismatch: ${parsed.type} !== ${ADDRESS_TYPE}`);
     return parsed;
 }
 function decode_p2wsh_script(script) {

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

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

package/dist/lib/address/script.js

@@ -1,46 +1,46 @@
 export function get_address_script(script_key, script_type) {
     switch (script_type) {
-        case 'p2pkh':
+        case "p2pkh":
             return get_p2pkh_script(script_key);
-        case 'p2sh':
+        case "p2sh":
             return get_p2sh_script(script_key);
-        case 'p2wpkh':
+        case "p2wpkh":
             return get_p2w_pkh_script(script_key);
-        case 'p2wsh':
+        case "p2wsh":
             return get_p2w_sh_script(script_key);
-        case 'p2tr':
+        case "p2tr":
             return get_p2tr_script(script_key);
         default:
-            throw new Error('unrecognized script type: ' + script_type);
+            throw new Error(`unrecognized script type: ${script_type}`);
     }
 }
 function get_p2pkh_script(script_key) {
     return {
-        hex: '76a914' + script_key + '88ac',
-        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 {
-        hex: 'a914' + script_key + '87',
-        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 {
-        hex: '0014' + script_key,
-        asm: ['OP_0', script_key]
+        hex: `0014${script_key}`,
+        asm: ["OP_0", script_key],
     };
 }
 function get_p2w_sh_script(script_key) {
     return {
-        hex: '0020' + script_key,
-        asm: ['OP_0', script_key]
+        hex: `0020${script_key}`,
+        asm: ["OP_0", script_key],
     };
 }
 function get_p2tr_script(script_key) {
     return {
-        hex: '5120' + script_key,
-        asm: ['OP_1', script_key]
+        hex: `5120${script_key}`,
+        asm: ["OP_1", script_key],
     };
 }

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

@@ -1,3 +1,3 @@
-import type { AddressConfig, AddressInfo, ChainNetwork, LockScriptType } from '../../types/index.js';
+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

@@ -1,24 +1,25 @@
-import { Buff } from '@vbyte/buff';
-import { decode_address } from './encode.js';
-import { get_address_script } from './script.js';
+import { Buff } from "@vbyte/buff";
+import { ConfigError } from "../../error.js";
+import { decode_address } from "./encode.js";
+import { get_address_script } from "./script.js";
 const CONFIG_TABLE = [
-    ['1', 'p2pkh', 'main', 20, 'base58', 0x00],
-    ['3', 'p2sh', 'main', 20, 'base58', 0x05],
-    ['m', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
-    ['n', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
-    ['2', 'p2sh', 'testnet', 20, 'base58', 0xC4],
-    ['m', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
-    ['n', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
-    ['2', 'p2sh', 'regtest', 20, 'base58', 0xC4],
-    ['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]
+    ["1", "p2pkh", "main", 20, "base58", 0x00],
+    ["3", "p2sh", "main", 20, "base58", 0x05],
+    ["m", "p2pkh", "testnet", 20, "base58", 0x6f],
+    ["n", "p2pkh", "testnet", 20, "base58", 0x6f],
+    ["2", "p2sh", "testnet", 20, "base58", 0xc4],
+    ["m", "p2pkh", "regtest", 20, "base58", 0x6f],
+    ["n", "p2pkh", "regtest", 20, "base58", 0x6f],
+    ["2", "p2sh", "regtest", 20, "base58", 0xc4],
+    ["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],
 ];
 export function get_address_config(address_network, address_type) {
     for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
@@ -45,9 +46,10 @@ export function get_address_info(address) {
             if (!address.startsWith(prefix))
                 continue;
         }
-        const data = Buff.uint(dec.data).hex;
+        const data = Buff.bytes(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');
+    throw new ConfigError(`unrecognized address configuration: format=${dec.format}, size=${dec.data.length}, version=${dec.version}. ` +
+        `Supported formats: base58 (p2pkh, p2sh), bech32 (p2wpkh, p2wsh), bech32m (p2tr)`);
 }

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

@@ -1,4 +1,4 @@
-export * from './locktime.js';
-export * from './ref.js';
-export * from './scribe.js';
-export * from './sequence.js';
+export * from "./locktime.js";
+export * from "./ref.js";
+export * from "./scribe.js";
+export * from "./sequence.js";