@vbyte/btc-dev 1.1.7 → 2.0.0

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/micro-lib";
+import { hash160 } from "@vbyte/micro-lib/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.size(bytes, 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}`);
     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/micro-lib";
+import { hash160 } from "@vbyte/micro-lib/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}`);
     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/micro-lib";
+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.size(bytes, 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}`);
     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/micro-lib";
+import { hash160 } from "@vbyte/micro-lib/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.size(bytes, 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}`);
     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/micro-lib";
+import { sha256 } from "@vbyte/micro-lib/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}`);
     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,24 @@
-import { Buff } from '@vbyte/buff';
-import { decode_address } from './encode.js';
-import { get_address_script } from './script.js';
+import { Buff } from "@vbyte/buff";
+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 +45,9 @@ 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 Error("address configuration is invalid");
 }

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";

package/dist/lib/meta/index.js

@@ -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";

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

@@ -1,4 +1,4 @@
-import type { LocktimeData } from '../../types/index.js';
+import type { LocktimeData } from "../../types/index.js";
 export declare namespace LocktimeField {
     const encode: typeof encode_locktime;
     const decode: typeof decode_locktime;

package/dist/lib/meta/locktime.js

@@ -1,4 +1,4 @@
-import { Assert } from '@vbyte/micro-lib';
+import { Assert } from "@vbyte/micro-lib";
 const LOCKTIME_THRESHOLD = 500000000;
 export var LocktimeField;
 (function (LocktimeField) {
@@ -7,31 +7,31 @@ export var LocktimeField;
 })(LocktimeField || (LocktimeField = {}));
 export function encode_locktime(locktime) {
     switch (locktime.type) {
-        case 'timelock':
-            Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, 'Invalid timestamp');
+        case "timelock":
+            Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, "Invalid timestamp");
             return locktime.stamp;
-        case 'heightlock':
-            Assert.ok(locktime.height > 0, 'height must be greater than 0');
-            Assert.ok(locktime.height < LOCKTIME_THRESHOLD, 'invalid block height');
+        case "heightlock":
+            Assert.ok(locktime.height > 0, "height must be greater than 0");
+            Assert.ok(locktime.height < LOCKTIME_THRESHOLD, "invalid block height");
             return locktime.height;
         default:
-            throw new Error('Invalid locktime type');
+            throw new Error("Invalid locktime type");
     }
 }
 export function decode_locktime(locktime) {
-    if (isNaN(locktime) || locktime <= 0) {
+    if (Number.isNaN(locktime) || locktime <= 0) {
         return null;
     }
     if (locktime < LOCKTIME_THRESHOLD) {
         return {
-            type: 'heightlock',
-            height: locktime
+            type: "heightlock",
+            height: locktime,
         };
     }
     else {
         return {
-            type: 'timelock',
-            stamp: locktime
+            type: "timelock",
+            stamp: locktime,
         };
     }
 }

package/dist/lib/meta/ref.js

@@ -24,8 +24,8 @@ function encode_inscription_id(txid, order = 0) {
 }
 function decode_inscription_id(inscription_id) {
     assert_inscription_id(inscription_id);
-    const [txid, order] = inscription_id.split('i');
-    return { txid, order: parseInt(order) };
+    const [txid, order] = inscription_id.split("i");
+    return { txid, order: parseInt(order, 10) };
 }
 function verify_inscription_id(inscription_id) {
     return inscription_id.match(/^[a-f0-9]{64}i\d+$/) !== null;
@@ -40,8 +40,11 @@ function encode_rune_id(block_height, block_index) {
 }
 function decode_rune_id(rune_id) {
     assert_rune_id(rune_id);
-    const [block_height, block_index] = rune_id.split(':');
-    return { block_height: parseInt(block_height), block_index: parseInt(block_index) };
+    const [block_height, block_index] = rune_id.split(":");
+    return {
+        block_height: parseInt(block_height, 10),
+        block_index: parseInt(block_index, 10),
+    };
 }
 function verify_rune_id(rune_id) {
     return rune_id.match(/^\d+:\d+$/) !== null;
@@ -56,8 +59,8 @@ function encode_outpoint(txid, vout) {
 }
 function decode_outpoint(outpoint) {
     assert_outpoint(outpoint);
-    const [txid, vout] = outpoint.split(':');
-    return { txid, vout: parseInt(vout) };
+    const [txid, vout] = outpoint.split(":");
+    return { txid, vout: parseInt(vout, 10) };
 }
 function verify_outpoint(outpoint) {
     return outpoint.match(/^[a-f0-9]{64}:[0-9]+$/) !== null;

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

@@ -1,5 +1,5 @@
-import { Buff, Bytes } from '@vbyte/buff';
-import type { InscriptionData } from '../../types/index.js';
+import { Buff, type Bytes } from "@vbyte/buff";
+import type { InscriptionData } from "../../types/index.js";
 export declare namespace InscriptionUtil {
     type Type = InscriptionData;
     const encode: typeof encode_inscription;