@vbyte/btc-dev 1.1.8 → 2.1.0

package/dist/lib/script/encode.js

@@ -1,5 +1,7 @@
-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 { ValidationError } from "../../error.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 +11,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 ValidationError(`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 +32,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 ValidationError(`invalid script word type: ${typeof word}. Expected string, number, or Uint8Array`);
     }
     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 +73,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 ValidationError(`invalid script word size: ${size}. Maximum allowed is ${MAX_WORD_SIZE} bytes`);
     }
 }

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]);
 }

package/dist/lib/script/words.js

@@ -1,148 +1,149 @@
+import { ValidationError } from "../../error.js";
 export const OPCODE_MAP = {
-    OP_0: 0,
-    OP_PUSHDATA1: 76,
-    OP_PUSHDATA2: 77,
-    OP_PUSHDATA4: 78,
-    OP_1NEGATE: 79,
-    OP_SUCCESS80: 80,
-    OP_1: 81,
-    OP_2: 82,
-    OP_3: 83,
-    OP_4: 84,
-    OP_5: 85,
-    OP_6: 86,
-    OP_7: 87,
-    OP_8: 88,
-    OP_9: 89,
-    OP_10: 90,
-    OP_11: 91,
-    OP_12: 92,
-    OP_13: 93,
-    OP_14: 94,
-    OP_15: 95,
-    OP_16: 96,
-    OP_NOP: 97,
-    OP_SUCCESS98: 98,
-    OP_IF: 99,
-    OP_NOTIF: 100,
-    OP_ELSE: 103,
-    OP_ENDIF: 104,
-    OP_VERIFY: 105,
-    OP_RETURN: 106,
-    OP_TOALTSTACK: 107,
-    OP_FROMALTSTACK: 108,
-    OP_2DROP: 109,
-    OP_2DUP: 110,
-    OP_3DUP: 111,
-    OP_2OVER: 112,
-    OP_2ROT: 113,
-    OP_2SWAP: 114,
-    OP_IFDUP: 115,
-    OP_DEPTH: 116,
-    OP_DROP: 117,
-    OP_DUP: 118,
-    OP_NIP: 119,
-    OP_OVER: 120,
-    OP_PICK: 121,
-    OP_ROLL: 122,
-    OP_ROT: 123,
-    OP_SWAP: 124,
-    OP_TUCK: 125,
-    OP_SUCCESS126: 126,
-    OP_SUCCESS127: 127,
-    OP_SUCCESS128: 128,
-    OP_SUCCESS129: 129,
-    OP_SIZE: 130,
-    OP_SUCCESS131: 131,
-    OP_SUCCESS132: 132,
-    OP_SUCCESS133: 133,
-    OP_SUCCESS134: 134,
-    OP_EQUAL: 135,
-    OP_EQUALVERIFY: 136,
-    OP_SUCCESS137: 137,
-    OP_SUCCESS138: 138,
-    OP_1ADD: 139,
-    OP_1SUB: 140,
-    OP_SUCCESS141: 141,
-    OP_SUCCESS142: 142,
-    OP_NEGATE: 143,
-    OP_ABS: 144,
-    OP_NOT: 145,
-    OP_0NOTEQUAL: 146,
-    OP_ADD: 147,
-    OP_SUB: 148,
-    OP_SUCCESS149: 149,
-    OP_SUCCESS150: 150,
-    OP_SUCCESS151: 151,
-    OP_SUCCESS152: 152,
-    OP_SUCCESS153: 153,
-    OP_BOOLAND: 154,
-    OP_BOOLOR: 155,
-    OP_NUMEQUAL: 156,
-    OP_NUMEQUALVERIFY: 157,
-    OP_NUMNOTEQUAL: 158,
-    OP_LESSTHAN: 159,
-    OP_GREATERTHAN: 160,
-    OP_LESSTHANOREQUAL: 161,
-    OP_GREATERTHANOREQUAL: 162,
-    OP_MIN: 163,
-    OP_MAX: 164,
-    OP_WITHIN: 165,
-    OP_RIPEMD160: 166,
-    OP_SHA1: 167,
-    OP_SHA256: 168,
-    OP_HASH160: 169,
-    OP_HASH256: 170,
-    OP_CODESEPARATOR: 171,
-    OP_CHECKSIG: 172,
-    OP_CHECKSIGVERIFY: 173,
-    OP_CHECKMULTISIG: 174,
-    OP_CHECKMULTISIGVERIFY: 175,
-    OP_NOP1: 176,
-    OP_CHECKLOCKTIMEVERIFY: 177,
-    OP_CHECKSEQUENCEVERIFY: 178,
-    OP_NOP4: 179,
-    OP_NOP5: 180,
-    OP_NOP6: 181,
-    OP_NOP7: 182,
-    OP_NOP8: 183,
-    OP_NOP9: 184,
-    OP_NOP10: 185,
-    OP_CHECKSIGADD: 186
+    OP_0: 0x00,
+    OP_PUSHDATA1: 0x4c,
+    OP_PUSHDATA2: 0x4d,
+    OP_PUSHDATA4: 0x4e,
+    OP_1NEGATE: 0x4f,
+    OP_SUCCESS80: 0x50,
+    OP_1: 0x51,
+    OP_2: 0x52,
+    OP_3: 0x53,
+    OP_4: 0x54,
+    OP_5: 0x55,
+    OP_6: 0x56,
+    OP_7: 0x57,
+    OP_8: 0x58,
+    OP_9: 0x59,
+    OP_10: 0x5a,
+    OP_11: 0x5b,
+    OP_12: 0x5c,
+    OP_13: 0x5d,
+    OP_14: 0x5e,
+    OP_15: 0x5f,
+    OP_16: 0x60,
+    OP_NOP: 0x61,
+    OP_SUCCESS98: 0x62,
+    OP_IF: 0x63,
+    OP_NOTIF: 0x64,
+    OP_ELSE: 0x67,
+    OP_ENDIF: 0x68,
+    OP_VERIFY: 0x69,
+    OP_RETURN: 0x6a,
+    OP_TOALTSTACK: 0x6b,
+    OP_FROMALTSTACK: 0x6c,
+    OP_2DROP: 0x6d,
+    OP_2DUP: 0x6e,
+    OP_3DUP: 0x6f,
+    OP_2OVER: 0x70,
+    OP_2ROT: 0x71,
+    OP_2SWAP: 0x72,
+    OP_IFDUP: 0x73,
+    OP_DEPTH: 0x74,
+    OP_DROP: 0x75,
+    OP_DUP: 0x76,
+    OP_NIP: 0x77,
+    OP_OVER: 0x78,
+    OP_PICK: 0x79,
+    OP_ROLL: 0x7a,
+    OP_ROT: 0x7b,
+    OP_SWAP: 0x7c,
+    OP_TUCK: 0x7d,
+    OP_SUCCESS126: 0x7e,
+    OP_SUCCESS127: 0x7f,
+    OP_SUCCESS128: 0x80,
+    OP_SUCCESS129: 0x81,
+    OP_SIZE: 0x82,
+    OP_SUCCESS131: 0x83,
+    OP_SUCCESS132: 0x84,
+    OP_SUCCESS133: 0x85,
+    OP_SUCCESS134: 0x86,
+    OP_EQUAL: 0x87,
+    OP_EQUALVERIFY: 0x88,
+    OP_SUCCESS137: 0x89,
+    OP_SUCCESS138: 0x8a,
+    OP_1ADD: 0x8b,
+    OP_1SUB: 0x8c,
+    OP_SUCCESS141: 0x8d,
+    OP_SUCCESS142: 0x8e,
+    OP_NEGATE: 0x8f,
+    OP_ABS: 0x90,
+    OP_NOT: 0x91,
+    OP_0NOTEQUAL: 0x92,
+    OP_ADD: 0x93,
+    OP_SUB: 0x94,
+    OP_SUCCESS149: 0x95,
+    OP_SUCCESS150: 0x96,
+    OP_SUCCESS151: 0x97,
+    OP_SUCCESS152: 0x98,
+    OP_SUCCESS153: 0x99,
+    OP_BOOLAND: 0x9a,
+    OP_BOOLOR: 0x9b,
+    OP_NUMEQUAL: 0x9c,
+    OP_NUMEQUALVERIFY: 0x9d,
+    OP_NUMNOTEQUAL: 0x9e,
+    OP_LESSTHAN: 0x9f,
+    OP_GREATERTHAN: 0xa0,
+    OP_LESSTHANOREQUAL: 0xa1,
+    OP_GREATERTHANOREQUAL: 0xa2,
+    OP_MIN: 0xa3,
+    OP_MAX: 0xa4,
+    OP_WITHIN: 0xa5,
+    OP_RIPEMD160: 0xa6,
+    OP_SHA1: 0xa7,
+    OP_SHA256: 0xa8,
+    OP_HASH160: 0xa9,
+    OP_HASH256: 0xaa,
+    OP_CODESEPARATOR: 0xab,
+    OP_CHECKSIG: 0xac,
+    OP_CHECKSIGVERIFY: 0xad,
+    OP_CHECKMULTISIG: 0xae,
+    OP_CHECKMULTISIGVERIFY: 0xaf,
+    OP_NOP1: 0xb0,
+    OP_CHECKLOCKTIMEVERIFY: 0xb1,
+    OP_CHECKSEQUENCEVERIFY: 0xb2,
+    OP_NOP4: 0xb3,
+    OP_NOP5: 0xb4,
+    OP_NOP6: 0xb5,
+    OP_NOP7: 0xb6,
+    OP_NOP8: 0xb7,
+    OP_NOP9: 0xb8,
+    OP_NOP10: 0xb9,
+    OP_CHECKSIGADD: 0xba,
 };
 export function get_op_code(num) {
     if (num > 186 && num < 255) {
-        return 'OP_SUCCESS' + String(num);
+        return `OP_SUCCESS${String(num)}`;
     }
     for (const [k, v] of Object.entries(OPCODE_MAP)) {
         if (v === num)
             return k;
     }
-    throw new Error('OPCODE not found:' + String(num));
+    throw new ValidationError(`opcode not found for value: ${num} (0x${num.toString(16)}). Valid range is 0x00-0xba`);
 }
 export function get_asm_code(string) {
     for (const [k, v] of Object.entries(OPCODE_MAP)) {
         if (k === string)
             return Number(v);
     }
-    throw new Error('OPCODE not found:' + string);
+    throw new ValidationError(`opcode not found: "${string}". Valid opcodes start with "OP_" (e.g., OP_DUP, OP_CHECKSIG)`);
 }
 export function get_op_type(word) {
     switch (true) {
-        case (word === 0):
-            return 'opcode';
-        case (word >= 1 && word <= 75):
-            return 'varint';
-        case (word === 76):
-            return 'pushdata1';
-        case (word === 77):
-            return 'pushdata2';
-        case (word === 78):
-            return 'pushdata4';
-        case (word <= 254):
-            return 'opcode';
+        case word === 0:
+            return "opcode";
+        case word >= 1 && word <= 75:
+            return "varint";
+        case word === 76:
+            return "pushdata1";
+        case word === 77:
+            return "pushdata2";
+        case word === 78:
+            return "pushdata4";
+        case word <= 254:
+            return "opcode";
         default:
-            throw new Error(`Invalid word range: ${word}`);
+            throw new ValidationError(`invalid word value: ${word}. Expected 0-254`);
     }
 }
 export function is_valid_op(word) {
@@ -150,13 +151,13 @@ export function is_valid_op(word) {
     const MAX_RANGE = 254;
     const DISABLED_OPCODES = [];
     switch (true) {
-        case (typeof (word) !== 'number'):
+        case typeof word !== "number":
             return false;
-        case (word === 0):
+        case word === 0:
             return true;
-        case (DISABLED_OPCODES.includes(word)):
+        case DISABLED_OPCODES.includes(word):
             return false;
-        case (MIN_RANGE < word && word < MAX_RANGE):
+        case MIN_RANGE < word && word < MAX_RANGE:
             return true;
         default:
             return false;

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

@@ -1,3 +1,3 @@
-export * from './segwit.js';
-export * from './taproot.js';
-export * from './util.js';
+export * from "./segwit.js";
+export * from "./taproot.js";
+export * from "./util.js";

package/dist/lib/sighash/index.js

@@ -1,3 +1,3 @@
-export * from './segwit.js';
-export * from './taproot.js';
-export * from './util.js';
+export * from "./segwit.js";
+export * from "./taproot.js";
+export * from "./util.js";

package/dist/lib/sighash/segwit.d.ts

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import { SigHashOptions, TxData, TxInput, TxOutput } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { SigHashOptions, TxData, TxInput, TxOutput } from "../../types/index.js";
 export declare function hash_segwit_tx(txdata: TxData, options?: SigHashOptions): Buff;
 export declare function bip143_hash_prevouts(vin: TxInput[], isAnypay?: boolean): Uint8Array;
 export declare function bip143_hash_sequence(vin: TxInput[], sigflag: number, isAnyPay: boolean): Uint8Array;

package/dist/lib/sighash/segwit.js

@@ -1,24 +1,27 @@
-import { Buff } from '@vbyte/buff';
-import { hash160, hash256 } from '@vbyte/micro-lib/hash';
-import { Assert } from '@vbyte/micro-lib';
-import { parse_txinput } from './util.js';
-import { prefix_script_size, decode_script } from '../../lib/script/index.js';
-import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version, parse_tx } from '../../lib/tx/index.js';
-import * as CONST from '../../const.js';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/util";
+import { hash160, hash256 } from "@vbyte/crypto/hash";
+import * as CONST from "../../const.js";
+import { ValidationError } from "../../error.js";
+import { decode_script, prefix_script_size } from "../../lib/script/index.js";
+import { encode_tx_locktime, encode_tx_version, encode_txin_sequence, encode_txin_txid, encode_txin_vout, encode_vout_value, parse_tx, } from "../../lib/tx/index.js";
+import { parse_txinput } from "./util.js";
 export function hash_segwit_tx(txdata, options = {}) {
     const { sigflag = 0x01, txindex } = options;
     const tx = parse_tx(txdata);
     const is_anypay = (sigflag & 0x80) === 0x80;
     const flag = sigflag % 0x80;
     if (!CONST.SIGHASH_SEGWIT.includes(flag)) {
-        throw new Error('Invalid hash type: ' + String(sigflag));
+        throw new ValidationError(`invalid sighash type: 0x${sigflag.toString(16)}. ` +
+            `Valid values: SIGHASH_ALL (0x01), SIGHASH_NONE (0x02), SIGHASH_SINGLE (0x03), ` +
+            `or combined with ANYONECANPAY (0x81, 0x82, 0x83)`);
     }
     const { version, vin, vout, locktime } = tx;
     const txinput = parse_txinput(tx, options);
     const { txid, vout: prevIdx, prevout, sequence } = txinput;
     const { value } = prevout ?? {};
     if (value === undefined) {
-        throw new Error('Prevout value is empty!');
+        throw new ValidationError("Prevout value is required for segwit sighash calculation", "prevout.value");
     }
     let { pubkey, script } = options;
     if (script === undefined && pubkey !== undefined) {
@@ -26,10 +29,10 @@ export function hash_segwit_tx(txdata, options = {}) {
         script = `76a914${String(pkhash)}88ac`;
     }
     if (script === undefined) {
-        throw new Error('No pubkey / script has been set!');
+        throw new ValidationError("Either pubkey or script must be provided for segwit sighash", "pubkey/script");
     }
-    if (decode_script(script).includes('OP_CODESEPARATOR')) {
-        throw new Error('This library does not currently support the use of OP_CODESEPARATOR in segwit scripts.');
+    if (decode_script(script).includes("OP_CODESEPARATOR")) {
+        throw new ValidationError("OP_CODESEPARATOR is not supported in segwit scripts", "script");
     }
     const sighash = [
         encode_tx_version(version),
@@ -42,7 +45,7 @@ export function hash_segwit_tx(txdata, options = {}) {
         encode_txin_sequence(sequence),
         bip143_hash_outputs(vout, flag, txindex),
         encode_tx_locktime(locktime),
-        Buff.num(sigflag, 4).reverse()
+        Buff.num(sigflag, 4).reverse(),
     ];
     return hash256(Buff.join(sighash));
 }
@@ -77,7 +80,8 @@ export function bip143_hash_outputs(vout, sigflag, idx) {
         return hash256(Buff.join(stack));
     }
     if (sigflag === 0x03) {
-        Assert.ok(idx !== undefined);
+        Assert.ok(idx !== undefined, "txindex required for SIGHASH_SINGLE");
+        Assert.ok(idx >= 0, "txindex must be non-negative");
         if (idx < vout.length) {
             const { value, script_pk } = vout[idx];
             stack.push(encode_vout_value(value));

package/dist/lib/sighash/taproot.d.ts

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import type { SigHashOptions, TxData, TxInput, TxOutput } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { SigHashOptions, TxData, TxInput, TxOutput } from "../../types/index.js";
 export declare function hash_taproot_tx(template: TxData | string, config?: SigHashOptions): Buff;
 export declare function get_taproot_tx_preimage(template: TxData | string, config?: SigHashOptions): Buff;
 export declare function bip341_hash_outpoints(vin: TxInput[]): Buff;