@vbyte/btc-dev 1.1.8 → 2.0.0

package/dist/lib/meta/scribe.js

@@ -1,7 +1,7 @@
-import { Buff, Stream } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { encode_script } from '../../lib/script/encode.js';
-import { decode_script } from '../../lib/script/decode.js';
+import { Buff, Stream } from "@vbyte/buff";
+import { Assert } from "@vbyte/micro-lib";
+import { decode_script } from "../../lib/script/decode.js";
+import { encode_script } from "../../lib/script/encode.js";
 const _0n = BigInt(0);
 const _1n = BigInt(1);
 const _26n = BigInt(26);
@@ -18,51 +18,51 @@ export function encode_inscription(data) {
     return Buff.join(data.map(create_envelope));
 }
 function create_envelope(data) {
-    let asm = ['OP_0', 'OP_IF', '6f7264'];
-    if (typeof data.delegate === 'string') {
+    const asm = ["OP_0", "OP_IF", "6f7264"];
+    if (typeof data.delegate === "string") {
         const id = encode_id(data.delegate);
-        asm.push('OP_11', id);
+        asm.push("OP_11", id);
     }
-    if (typeof data.ref === 'string') {
-        asm.push('OP_WITHIN', data.ref);
+    if (typeof data.ref === "string") {
+        asm.push("OP_WITHIN", data.ref);
     }
-    if (typeof data.parent === 'string') {
+    if (typeof data.parent === "string") {
         const id = encode_id(data.parent);
-        asm.push('OP_3', id);
+        asm.push("OP_3", id);
     }
-    if (typeof data.opcode === 'number') {
+    if (typeof data.opcode === "number") {
         const code = encode_pointer(data.opcode);
-        asm.push('OP_NOP', code);
+        asm.push("OP_NOP", code);
     }
-    if (typeof data.pointer === 'number') {
+    if (typeof data.pointer === "number") {
         const ptr = encode_pointer(data.pointer);
-        asm.push('OP_2', ptr);
+        asm.push("OP_2", ptr);
     }
-    if (typeof data.rune === 'string') {
+    if (typeof data.rune === "string") {
         const label = encode_rune_label(data.rune);
-        asm.push('OP_13', label);
+        asm.push("OP_13", label);
     }
-    if (typeof data.mimetype === 'string') {
+    if (typeof data.mimetype === "string") {
         const label = encode_label(data.mimetype);
-        asm.push('OP_1', label);
+        asm.push("OP_1", label);
     }
-    if (typeof data.content === 'string') {
+    if (typeof data.content === "string") {
         const chunks = encode_content(data.content);
-        asm.push('OP_0', ...chunks);
+        asm.push("OP_0", ...chunks);
     }
-    asm.push('OP_ENDIF');
+    asm.push("OP_ENDIF");
     return encode_script(asm);
 }
 function parse_envelopes(script) {
     const words = decode_script(script);
-    const start_idx = words.findIndex(e => e === 'OP_0');
-    Assert.ok(start_idx !== -1, 'inscription envelope not found');
+    const start_idx = words.indexOf("OP_0");
+    Assert.ok(start_idx !== -1, "inscription envelope not found");
     const envelopes = [];
     for (let idx = start_idx; idx < words.length; idx++) {
-        Assert.ok(words[idx + 1] === 'OP_IF', 'OP_IF missing from envelope');
-        Assert.ok(words[idx + 2] === '6f7264', 'magic bytes missing from envelope');
-        const stop_idx = words.findIndex(e => e === 'OP_ENDIF');
-        Assert.ok(stop_idx !== -1, 'inscription envelope missing END_IF statement');
+        Assert.ok(words[idx + 1] === "OP_IF", "OP_IF missing from envelope");
+        Assert.ok(words[idx + 2] === "6f7264", "magic bytes missing from envelope");
+        const stop_idx = words.indexOf("OP_ENDIF");
+        Assert.ok(stop_idx !== -1, "inscription envelope missing END_IF statement");
         const env = words.slice(idx + 3, stop_idx);
         envelopes.push(env);
         idx += stop_idx;
@@ -73,35 +73,35 @@ function parse_record(envelope) {
     const record = {};
     for (let i = 0; i < envelope.length; i++) {
         switch (envelope[i]) {
-            case 'OP_1':
+            case "OP_1":
                 record.mimetype = decode_label(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_2':
+            case "OP_2":
                 record.pointer = decode_pointer(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_3':
+            case "OP_3":
                 record.parent = decode_id(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_11':
+            case "OP_11":
                 record.delegate = decode_id(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_13':
+            case "OP_13":
                 record.rune = decode_rune_label(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_WITHIN':
+            case "OP_WITHIN":
                 record.ref = decode_bytes(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_NOP':
+            case "OP_NOP":
                 record.opcode = decode_pointer(envelope[i + 1]);
                 i += 1;
                 break;
-            case 'OP_0':
+            case "OP_0":
                 record.content = decode_content(envelope.slice(i + 1));
                 return record;
         }
@@ -112,18 +112,18 @@ function decode_bytes(bytes) {
     return Buff.bytes(bytes).hex;
 }
 function encode_id(identifier) {
-    Assert.ok(identifier.includes('i'), 'identifier must include an index');
-    const parts = identifier.split('i');
+    Assert.ok(identifier.includes("i"), "identifier must include an index");
+    const parts = identifier.split("i");
     const bytes = Buff.hex(parts[0]);
     const idx = Number(parts[1]);
     const txid = bytes.reverse().hex;
-    return (idx !== 0) ? txid + Buff.num(idx).hex : txid;
+    return idx !== 0 ? txid + Buff.num(idx).hex : txid;
 }
 function decode_id(identifier) {
     const bytes = Buff.bytes(identifier);
     const idx = bytes.at(-1) ?? 0;
     const txid = bytes.slice(0, -1).reverse().hex;
-    return txid + 'i' + String(idx);
+    return `${txid}i${String(idx)}`;
 }
 function encode_pointer(pointer) {
     return Buff.num(pointer).reverse().hex;
@@ -138,9 +138,7 @@ function decode_label(label) {
     return Buff.bytes(label).str;
 }
 function encode_content(content) {
-    const bytes = Buff.is_hex(content)
-        ? Buff.hex(content)
-        : Buff.str(content);
+    const bytes = Buff.is_hex(content) ? Buff.hex(content) : Buff.str(content);
     const stream = new Stream(bytes);
     const chunks = [];
     while (stream.size > 0) {
@@ -155,21 +153,18 @@ function encode_content(content) {
     }
     return chunks;
 }
-function decode_content(chunks, format = 'hex') {
+function decode_content(chunks, format = "hex") {
     const data = Buff.join(chunks);
-    return (format === 'hex')
-        ? data.hex
-        : data.str;
+    return format === "hex" ? data.hex : data.str;
 }
 function encode_rune_label(label) {
     const str = label.toUpperCase();
     let big = _0n;
     for (const char of str) {
-        if (char >= 'A' && char <= 'Z') {
-            big = big * _26n + BigInt(char.charCodeAt(0) - ('A'.charCodeAt(0) - 1));
+        if (char >= "A" && char <= "Z") {
+            big = big * _26n + BigInt(char.charCodeAt(0) - ("A".charCodeAt(0) - 1));
         }
         else {
-            continue;
         }
     }
     big = big - _1n;
@@ -178,15 +173,15 @@ function encode_rune_label(label) {
 function decode_rune_label(label) {
     let big = Buff.bytes(label).reverse().big;
     big = big + _1n;
-    let result = '';
+    let result = "";
     while (big > _0n) {
         const mod = big % _26n;
         if (mod === _0n) {
-            result = 'Z' + result;
+            result = `Z${result}`;
             big = big / _26n - _1n;
         }
         else {
-            const charCode = Number(mod) + 'A'.charCodeAt(0) - 1;
+            const charCode = Number(mod) + "A".charCodeAt(0) - 1;
             result = String.fromCharCode(charCode) + result;
             big = big / _26n;
         }

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

@@ -1,4 +1,4 @@
-import type { SequenceConfig, SequenceData } from '../../types/index.js';
+import type { SequenceConfig, SequenceData } from "../../types/index.js";
 export declare namespace SequenceField {
     const encode: typeof encode_sequence;
     const decode: typeof decode_sequence;

package/dist/lib/meta/sequence.js

@@ -1,7 +1,7 @@
 const TIMELOCK_DISABLE = 0x80000000;
 const TIMELOCK_TYPE = 0x00400000;
-const TIMELOCK_VALUE_MASK = 0x0000FFFF;
-const TIMELOCK_VALUE_MAX = 0xFFFF;
+const TIMELOCK_VALUE_MASK = 0x0000ffff;
+const TIMELOCK_VALUE_MAX = 0xffff;
 const TIMELOCK_GRANULARITY = 512;
 export var SequenceField;
 (function (SequenceField) {
@@ -9,15 +9,15 @@ export var SequenceField;
     SequenceField.decode = decode_sequence;
 })(SequenceField || (SequenceField = {}));
 export function encode_sequence(data) {
-    if (data.mode === 'height') {
+    if (data.mode === "height") {
         const height = parse_height(data.height);
         return (height & TIMELOCK_VALUE_MASK) >>> 0;
     }
-    if (data.mode === 'stamp') {
+    if (data.mode === "stamp") {
         const stamp = parse_stamp(data.stamp);
         return (TIMELOCK_TYPE | (stamp & TIMELOCK_VALUE_MASK)) >>> 0;
     }
-    throw new Error('invalid timelock mode: ' + data.mode);
+    throw new Error(`invalid timelock mode: ${data.mode}`);
 }
 export function decode_sequence(sequence) {
     const seq = parse_sequence(sequence);
@@ -26,23 +26,21 @@ export function decode_sequence(sequence) {
     const value = seq & TIMELOCK_VALUE_MASK;
     if (seq & TIMELOCK_TYPE) {
         const stamp = value * TIMELOCK_GRANULARITY;
-        if (stamp > 0xFFFFFFFF) {
-            throw new Error('Decoded timestamp exceeds 32-bit limit');
+        if (stamp > 0xffffffff) {
+            throw new Error("Decoded timestamp exceeds 32-bit limit");
         }
-        return { mode: 'stamp', stamp };
+        return { mode: "stamp", stamp };
     }
     else {
         if (value > TIMELOCK_VALUE_MAX) {
-            throw new Error('Decoded height exceeds maximum');
+            throw new Error("Decoded height exceeds maximum");
         }
-        return { mode: 'height', height: value };
+        return { mode: "height", height: value };
     }
 }
 function parse_sequence(sequence) {
-    const seq = (typeof sequence === 'string')
-        ? parseInt(sequence, 16)
-        : sequence;
-    if (!Number.isInteger(seq) || seq < 0 || seq > 0xFFFFFFFF) {
+    const seq = typeof sequence === "string" ? parseInt(sequence, 16) : sequence;
+    if (!Number.isInteger(seq) || seq < 0 || seq > 0xffffffff) {
         throw new Error(`invalid sequence value: ${seq}`);
     }
     return seq;
@@ -58,7 +56,10 @@ function parse_stamp(stamp) {
     return ts;
 }
 function parse_height(height) {
-    if (height === undefined || !Number.isInteger(height) || height < 0 || height > TIMELOCK_VALUE_MAX) {
+    if (height === undefined ||
+        !Number.isInteger(height) ||
+        height < 0 ||
+        height > TIMELOCK_VALUE_MAX) {
         throw new Error(`Heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}`);
     }
     return height;

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

@@ -1,5 +1,5 @@
-import { Bytes } from '@vbyte/buff';
-import type { ScriptInfo } from '../../types/script.js';
+import { type 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,10 +1,10 @@
-import { Buff, Stream } from '@vbyte/buff';
-import { get_op_code, get_op_type, is_valid_op } from './words.js';
+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
+        hex: bytes.hex,
     };
 }
 export function decode_script(script) {
@@ -20,26 +20,61 @@ export function decode_script(script) {
         word_type = get_op_type(word);
         count++;
         switch (word_type) {
-            case 'varint':
-                stack.push(stream.read(word).hex);
+            case "varint":
+                try {
+                    stack.push(stream.read(word).hex);
+                }
+                catch {
+                    throw new Error(`Malformed script: varint push at position ${count - 1} requires ${word} bytes but stream exhausted`);
+                }
                 count += word;
                 break;
-            case 'pushdata1':
-                word_size = stream.read(1).reverse().num;
-                stack.push(stream.read(word_size).hex);
+            case "pushdata1":
+                try {
+                    word_size = stream.read(1).reverse().num;
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA1 at position ${count - 1} missing size byte`);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA1 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                }
                 count += word_size + 1;
                 break;
-            case 'pushdata2':
-                word_size = stream.read(2).reverse().num;
-                stack.push(stream.read(word_size).hex);
+            case "pushdata2":
+                try {
+                    word_size = stream.read(2).reverse().num;
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA2 at position ${count - 1} missing size bytes`);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA2 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                }
                 count += word_size + 2;
                 break;
-            case 'pushdata4':
-                word_size = stream.read(4).reverse().num;
-                stack.push(stream.read(word_size).hex);
+            case "pushdata4":
+                try {
+                    word_size = stream.read(4).reverse().num;
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA4 at position ${count - 1} missing size bytes`);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new Error(`Malformed script: PUSHDATA4 at position ${count - 1} requires ${word_size} bytes but stream exhausted`);
+                }
                 count += word_size + 4;
                 break;
-            case 'opcode':
+            case "opcode":
                 if (!is_valid_op(word)) {
                     throw new Error(`Invalid OPCODE: ${word}`);
                 }

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

@@ -1,4 +1,4 @@
-import { Buff } from '@vbyte/buff';
+import { Buff } from "@vbyte/buff";
 export declare function encode_script(words: (string | number | Uint8Array)[], varint?: boolean): Buff;
 export declare function encode_script_word(word: string | number | Uint8Array): Uint8Array;
 export declare function split_script_word(word: Uint8Array): Buff[];

package/dist/lib/script/encode.js

@@ -1,5 +1,6 @@
-import { Buff, Stream } from '@vbyte/buff';
-import { get_asm_code, } from './words.js';
+import { Buff, Stream } from "@vbyte/buff";
+import { MAX_SCRIPT_SIZE, OP_1_OFFSET } from "../../const.js";
+import { get_asm_code } from "./words.js";
 const MAX_WORD_SIZE = 520;
 export function encode_script(words, varint = false) {
     if (words.length === 0)
@@ -9,14 +10,17 @@ export function encode_script(words, varint = false) {
         bytes.push(encode_script_word(word));
     }
     const buffer = Buff.join(bytes);
-    return (varint)
-        ? buffer.prepend(Buff.varint(buffer.length, 'le'))
+    if (buffer.length > MAX_SCRIPT_SIZE) {
+        throw new Error(`script size ${buffer.length} exceeds consensus limit of ${MAX_SCRIPT_SIZE} bytes`);
+    }
+    return varint
+        ? buffer.prepend(Buff.create_varint(buffer.length, "le"))
         : buffer;
 }
 export function encode_script_word(word) {
     let buff;
-    if (typeof (word) === 'string') {
-        if (word.startsWith('OP_')) {
+    if (typeof word === "string") {
+        if (word.startsWith("OP_")) {
             const asm_code = get_asm_code(word);
             return Buff.num(asm_code, 1);
         }
@@ -27,23 +31,23 @@ export function encode_script_word(word) {
             buff = Buff.str(word);
         }
     }
-    else if (typeof (word) === 'number') {
+    else if (typeof word === "number") {
         buff = Buff.num(word);
     }
     else if (word instanceof Uint8Array) {
         buff = new Buff(word);
     }
     else {
-        throw new Error('invalid word type:' + typeof (word));
+        throw new Error(`invalid word type:${typeof word}`);
     }
     if (buff.length === 1 && buff[0] <= 16) {
         if (buff[0] !== 0)
-            buff[0] += 0x50;
+            buff[0] += OP_1_OFFSET;
     }
     else if (buff.length > MAX_WORD_SIZE) {
         let words;
         words = split_script_word(buff);
-        words = words.map(e => prefix_word_size(e));
+        words = words.map((e) => prefix_word_size(e));
         buff = Buff.join(words);
     }
     else {
@@ -68,13 +72,13 @@ export function get_size_varint(size) {
     const OP_PUSHDATA1 = Buff.num(0x4c, 1);
     const OP_PUSHDATA2 = Buff.num(0x4d, 1);
     switch (true) {
-        case (size <= 0x4b):
+        case size <= 0x4b:
             return Buff.num(size);
-        case (size > 0x4b && size < 0x100):
-            return Buff.join([OP_PUSHDATA1, Buff.num(size, 1, 'le')]);
-        case (size >= 0x100 && size <= MAX_WORD_SIZE):
-            return Buff.join([OP_PUSHDATA2, Buff.num(size, 2, 'le')]);
+        case size > 0x4b && size < 0x100:
+            return Buff.join([OP_PUSHDATA1, Buff.num(size, 1, "le")]);
+        case size >= 0x100 && size <= MAX_WORD_SIZE:
+            return Buff.join([OP_PUSHDATA2, Buff.num(size, 2, "le")]);
         default:
-            throw new Error('Invalid word size:' + size.toString());
+            throw new Error(`Invalid word size:${size.toString()}`);
     }
 }

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

@@ -1,13 +1,5 @@
-import { encode_script } from './encode.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 parse: typeof parse_script;
-    const decode: typeof decode_script;
-    const encode: typeof encode_script;
-    const is_valid: typeof is_valid_script;
-}
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./lock.js";
+export * from "./util.js";
+export * from "./words.js";

package/dist/lib/script/index.js

@@ -1,14 +1,5 @@
-import { encode_script } from './encode.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.parse = parse_script;
-    ScriptUtil.decode = decode_script;
-    ScriptUtil.encode = encode_script;
-    ScriptUtil.is_valid = is_valid_script;
-})(ScriptUtil || (ScriptUtil = {}));
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./lock.js";
+export * from "./util.js";
+export * from "./words.js";

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

@@ -1,5 +1,5 @@
-import { Bytes } from '@vbyte/buff';
-import type { LockScriptInfo, LockScriptType, WitnessVersion } from '../../types/index.js';
+import { type 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;

package/dist/lib/script/lock.js

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import { LOCK_SCRIPT_REGEX } from '../../const.js';
+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;
@@ -7,7 +7,7 @@ export function is_return_script(script) {
 export function get_lock_script_info(script) {
     return {
         type: get_lock_script_type(script),
-        version: get_lock_script_version(script)
+        version: get_lock_script_version(script),
     };
 }
 export function get_lock_script_type(script) {
@@ -21,32 +21,35 @@ export function get_lock_script_type(script) {
 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;
+        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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    return LOCK_SCRIPT_REGEX.opreturn.test(hex);
 }

package/dist/lib/script/util.js

@@ -1,10 +1,10 @@
-import { Buff } from '@vbyte/buff';
+import { Buff } from "@vbyte/buff";
 export function prefix_script_size(script) {
-    return Buff.bytes(script).prefix_varint('le').hex;
+    return Buff.bytes(script).prefix_varint("le").hex;
 }
 export function parse_script_pubkeys(script) {
-    const scriptHex = typeof script === 'string' ? script : Buff.bytes(script).hex;
+    const scriptHex = typeof script === "string" ? script : Buff.bytes(script).hex;
     const pubkeyPattern = /20([0-9a-f]{64})(ac|ad|ba)/gi;
     const matches = [...scriptHex.matchAll(pubkeyPattern)];
-    return matches.map(match => match[1]);
+    return matches.map((match) => match[1]);
 }