@vbyte/btc-dev 1.1.8 → 2.1.0

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,5 @@
-import { Assert } from '@vbyte/micro-lib';
+import { Assert } from "@vbyte/util";
+import { ConfigError } from "../../error.js";
 const LOCKTIME_THRESHOLD = 500000000;
 export var LocktimeField;
 (function (LocktimeField) {
@@ -7,31 +8,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 ConfigError(`Invalid locktime type: expected 'timelock' or 'heightlock'`);
     }
 }
 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

@@ -1,3 +1,4 @@
+import { ValidationError } from "../../error.js";
 export var RefPointer;
 (function (RefPointer) {
     RefPointer.outpoint = {
@@ -24,15 +25,15 @@ 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;
 }
 function assert_inscription_id(inscription_id) {
     if (!verify_inscription_id(inscription_id)) {
-        throw new Error(`invalid inscription id: ${inscription_id}`);
+        throw new ValidationError(`invalid inscription id: "${inscription_id}". Expected format: <64-char-txid>i<index> (e.g., "abc123...i0")`);
     }
 }
 function encode_rune_id(block_height, block_index) {
@@ -40,15 +41,18 @@ 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;
 }
 function assert_rune_id(rune_id) {
     if (!verify_rune_id(rune_id)) {
-        throw new Error(`invalid rune id: ${rune_id}`);
+        throw new ValidationError(`invalid rune id: "${rune_id}". Expected format: <block_height>:<block_index> (e.g., "840000:1")`);
     }
 }
 function encode_outpoint(txid, vout) {
@@ -56,14 +60,14 @@ 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;
 }
 function assert_outpoint(outpoint) {
     if (!verify_outpoint(outpoint)) {
-        throw new Error(`invalid outpoint: ${outpoint}`);
+        throw new ValidationError(`invalid outpoint: "${outpoint}". Expected format: <64-char-txid>:<vout> (e.g., "abc123...:0")`);
     }
 }

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;

package/dist/lib/meta/scribe.js

@@ -1,7 +1,8 @@
-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/util";
+import { ValidationError } from "../../error.js";
+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,54 +19,55 @@ 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(idx + 2 < words.length, "incomplete envelope: missing OP_IF or magic bytes");
+        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", idx);
+        Assert.ok(stop_idx !== -1, "inscription envelope missing OP_ENDIF statement");
         const env = words.slice(idx + 3, stop_idx);
         envelopes.push(env);
-        idx += stop_idx;
+        idx = stop_idx;
     }
     return envelopes;
 }
@@ -73,35 +75,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;
         }
@@ -111,25 +113,41 @@ function parse_record(envelope) {
 function decode_bytes(bytes) {
     return Buff.bytes(bytes).hex;
 }
+function normalize_script_word(word) {
+    if (typeof word === "string" && word.startsWith("OP_")) {
+        if (word === "OP_0")
+            return Buff.num(0).hex;
+        const match = word.match(/^OP_(\d+)$/);
+        if (match) {
+            const num = parseInt(match[1], 10);
+            if (num >= 1 && num <= 16)
+                return Buff.num(num).hex;
+        }
+    }
+    return word;
+}
 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);
+    if (bytes.length === 32) {
+        return `${bytes.reverse().hex}i0`;
+    }
     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;
 }
 function decode_pointer(bytes) {
-    return Buff.bytes(bytes).reverse().num;
+    return Buff.bytes(normalize_script_word(bytes)).reverse().num;
 }
 function encode_label(label) {
     return Buff.str(label).hex;
@@ -138,9 +156,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,38 +171,37 @@ 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;
+            throw new ValidationError(`invalid character in rune label: '${char}' (only A-Z allowed)`, "label");
         }
     }
     big = big - _1n;
     return Buff.big(big).reverse().hex;
 }
 function decode_rune_label(label) {
-    let big = Buff.bytes(label).reverse().big;
+    const normalized = normalize_script_word(label);
+    let big = Buff.bytes(normalized).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,8 @@
+import { ValidationError } from "../../error.js";
 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 +10,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 ValidationError(`invalid timelock mode: "${data.mode}". Valid modes are "height" or "stamp"`);
 }
 export function decode_sequence(sequence) {
     const seq = parse_sequence(sequence);
@@ -26,40 +27,41 @@ 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 ValidationError(`decoded timestamp ${stamp} exceeds 32-bit limit (max: ${0xffffffff})`);
         }
-        return { mode: 'stamp', stamp };
+        return { mode: "stamp", stamp };
     }
     else {
         if (value > TIMELOCK_VALUE_MAX) {
-            throw new Error('Decoded height exceeds maximum');
+            throw new ValidationError(`decoded height ${value} exceeds maximum (${TIMELOCK_VALUE_MAX})`);
         }
-        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) {
-        throw new Error(`invalid sequence value: ${seq}`);
+    const seq = typeof sequence === "string" ? parseInt(sequence, 16) : sequence;
+    if (!Number.isInteger(seq) || seq < 0 || seq > 0xffffffff) {
+        throw new ValidationError(`invalid sequence value: ${seq}. Must be an integer between 0 and 0xffffffff`);
     }
     return seq;
 }
 function parse_stamp(stamp) {
     if (stamp === undefined || !Number.isInteger(stamp)) {
-        throw new Error(`timestamp must be a number`);
+        throw new ValidationError(`timestamp must be an integer, got: ${stamp}`);
     }
     const ts = Math.floor(stamp / TIMELOCK_GRANULARITY);
     if (!Number.isInteger(ts) || ts < 0 || ts > TIMELOCK_VALUE_MAX) {
-        throw new Error(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
+        throw new ValidationError(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
     }
     return ts;
 }
 function parse_height(height) {
-    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}`);
+    if (height === undefined ||
+        !Number.isInteger(height) ||
+        height < 0 ||
+        height > TIMELOCK_VALUE_MAX) {
+        throw new ValidationError(`heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}, got: ${height}`);
     }
     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,11 @@
-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 { DecodingError } from "../../error.js";
+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,33 +21,68 @@ 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 DecodingError(`Malformed script: varint push at position ${count - 1} requires ${word} bytes but stream exhausted`, count - 1);
+                }
                 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 DecodingError(`Malformed script: PUSHDATA1 at position ${count - 1} missing size byte`, count - 1);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new DecodingError(`Malformed script: PUSHDATA1 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
+                }
                 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 DecodingError(`Malformed script: PUSHDATA2 at position ${count - 1} missing size bytes`, count - 1);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new DecodingError(`Malformed script: PUSHDATA2 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
+                }
                 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 DecodingError(`Malformed script: PUSHDATA4 at position ${count - 1} missing size bytes`, count - 1);
+                }
+                try {
+                    stack.push(stream.read(word_size).hex);
+                }
+                catch {
+                    throw new DecodingError(`Malformed script: PUSHDATA4 at position ${count - 1} requires ${word_size} bytes but stream exhausted`, count - 1);
+                }
                 count += word_size + 4;
                 break;
-            case 'opcode':
+            case "opcode":
                 if (!is_valid_op(word)) {
-                    throw new Error(`Invalid OPCODE: ${word}`);
+                    throw new DecodingError(`Invalid OPCODE: ${word}`, count - 1);
                 }
                 stack.push(get_op_code(word));
                 break;
             default:
-                throw new Error(`Word type undefined: ${word}`);
+                throw new DecodingError(`Word type undefined: ${word}`, count - 1);
         }
     }
     return stack;

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[];