@vbyte/btc-dev 1.1.7 → 2.0.0

package/dist/lib/script/words.js

@@ -1,146 +1,146 @@
 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 Error(`OPCODE not found:${String(num)}`);
 }
 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 Error(`OPCODE not found:${string}`);
 }
 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}`);
     }
@@ -150,13 +150,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,24 @@
-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/micro-lib";
+import { hash160, hash256 } from "@vbyte/micro-lib/hash";
+import * as CONST from "../../const.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 Error(`Invalid hash type: ${String(sigflag)}`);
     }
     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 Error("Prevout value is empty!");
     }
     let { pubkey, script } = options;
     if (script === undefined && pubkey !== undefined) {
@@ -26,10 +26,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 Error("No pubkey / script has been set!");
     }
-    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 Error("This library does not currently support the use of OP_CODESEPARATOR in segwit scripts.");
     }
     const sighash = [
         encode_tx_version(version),
@@ -42,7 +42,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 +77,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;

package/dist/lib/sighash/taproot.js

@@ -1,26 +1,26 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { hash340, sha256 } from '@vbyte/micro-lib/hash';
-import { encode_tapscript } from '../../lib/taproot/encode.js';
-import { parse_tx } from '../../lib/tx/parse.js';
-import * as CONST from '../../const.js';
-import { parse_txinput, get_annex_data, get_prevout } from './util.js';
-import { encode_txin_vout, encode_tx_locktime, encode_txin_sequence, encode_txin_txid, encode_vout_value, encode_tx_version, encode_script_data } from '../../lib/tx/encode.js';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/micro-lib";
+import { hash340, sha256 } from "@vbyte/micro-lib/hash";
+import * as CONST from "../../const.js";
+import { encode_tapscript } from "../../lib/taproot/encode.js";
+import { encode_script_data, encode_tx_locktime, encode_tx_version, encode_txin_sequence, encode_txin_txid, encode_txin_vout, encode_vout_value, } from "../../lib/tx/encode.js";
+import { parse_tx } from "../../lib/tx/parse.js";
+import { get_annex_data, get_prevout, parse_txinput } from "./util.js";
 export function hash_taproot_tx(template, config = {}) {
     const preimage = get_taproot_tx_preimage(template, config);
-    return hash340('TapSighash', preimage);
+    return hash340("TapSighash", preimage);
 }
 export function get_taproot_tx_preimage(template, config = {}) {
-    const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xFFFFFFFF } = config;
+    const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xffffffff, } = config;
     const tx = parse_tx(template);
     const { version, vin: input, vout: output, locktime } = tx;
     const txinput = parse_txinput(tx, config);
     const { txid, vout, sequence, witness = [] } = txinput;
     if (!CONST.SIGHASH_TAPROOT.includes(sigflag)) {
-        throw new Error('Invalid hash type: ' + String(sigflag));
+        throw new Error(`Invalid hash type: ${String(sigflag)}`);
     }
     if (extflag < 0 || extflag > 127) {
-        throw new Error('Extention flag out of range: ' + String(extflag));
+        throw new Error(`Extention flag out of range: ${String(extflag)}`);
     }
     let { extension } = config;
     if (script !== undefined) {
@@ -28,17 +28,17 @@ export function get_taproot_tx_preimage(template, config = {}) {
     }
     const is_anypay = (sigflag & 0x80) === 0x80;
     const annex = get_annex_data(witness);
-    const annexBit = (annex !== undefined) ? 1 : 0;
-    const extendBit = (extension !== undefined) ? 1 : 0;
-    const spendType = ((extflag + extendBit) * 2) + annexBit;
+    const annexBit = annex !== undefined ? 1 : 0;
+    const extendBit = extension !== undefined ? 1 : 0;
+    const spendType = (extflag + extendBit) * 2 + annexBit;
     const preimage = [
         Buff.num(0x00, 1),
         Buff.num(sigflag, 1),
         encode_tx_version(version),
-        encode_tx_locktime(locktime)
+        encode_tx_locktime(locktime),
     ];
     if (!is_anypay) {
-        const prevouts = input.map(e => get_prevout(e));
+        const prevouts = input.map((e) => get_prevout(e));
         preimage.push(bip341_hash_outpoints(input), bip341_hash_amounts(prevouts), bip341_hash_scripts(prevouts), bip341_hash_sequence(input));
     }
     if ((sigflag & 0x03) < 2 || (sigflag & 0x03) > 3) {
@@ -50,18 +50,19 @@ export function get_taproot_tx_preimage(template, config = {}) {
         preimage.push(encode_txin_txid(txid), encode_txin_vout(vout), encode_vout_value(value), encode_script_data(script_pk), encode_txin_sequence(sequence));
     }
     else {
-        Assert.ok(typeof txindex === 'number');
+        Assert.ok(typeof txindex === "number");
         preimage.push(Buff.num(txindex, 4).reverse());
     }
     if (annex !== undefined) {
         preimage.push(annex);
     }
     if ((sigflag & 0x03) === 0x03) {
-        Assert.ok(typeof txindex === 'number');
+        Assert.ok(typeof txindex === "number", "txindex required for SIGHASH_SINGLE");
+        Assert.ok(txindex >= 0 && txindex < output.length, `txindex ${txindex} out of bounds for ${output.length} outputs`);
         preimage.push(bip341_hash_output(output[txindex]));
     }
     if (extension !== undefined) {
-        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4, 'le'));
+        preimage.push(Buff.bytes(extension), Buff.num(key_version), Buff.num(separator_pos, 4, "le"));
     }
     return Buff.join(preimage);
 }
@@ -74,13 +75,13 @@ export function bip341_hash_outpoints(vin) {
     return sha256(Buff.join(stack));
 }
 export function bip341_hash_sequence(vin) {
-    return sha256(...vin.map(vin => encode_txin_sequence(vin.sequence)));
+    return sha256(...vin.map((vin) => encode_txin_sequence(vin.sequence)));
 }
 export function bip341_hash_amounts(prevouts) {
-    return sha256(...prevouts.map(prevout => encode_vout_value(prevout.value)));
+    return sha256(...prevouts.map((prevout) => encode_vout_value(prevout.value)));
 }
 export function bip341_hash_scripts(prevouts) {
-    return sha256(...prevouts.map(prevout => encode_script_data(prevout.script_pk)));
+    return sha256(...prevouts.map((prevout) => encode_script_data(prevout.script_pk)));
 }
 export function bip341_hash_outputs(vout) {
     const stack = [];

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

@@ -1,5 +1,5 @@
-import { Buff } from '@vbyte/buff';
-import type { SigHashOptions, TxInput, TxData, TxOutput } from '../../types/index.js';
+import { Buff } from "@vbyte/buff";
+import type { SigHashOptions, TxData, TxInput, TxOutput } from "../../types/index.js";
 export declare function get_prevout(vin: TxInput): TxOutput;
 export declare function parse_txinput(txdata: TxData, config?: SigHashOptions): TxInput;
 export declare function get_annex_data(witness?: string[]): Buff | undefined;

package/dist/lib/sighash/util.js

@@ -1,15 +1,15 @@
-import { Buff } from '@vbyte/buff';
-import { Assert } from '@vbyte/micro-lib';
-import { sha256 } from '@vbyte/micro-lib/hash';
+import { Buff } from "@vbyte/buff";
+import { Assert } from "@vbyte/micro-lib";
+import { sha256 } from "@vbyte/micro-lib/hash";
 export function get_prevout(vin) {
-    Assert.exists(vin.prevout, 'Prevout data missing for input: ' + String(vin.txid));
+    Assert.exists(vin.prevout, `Prevout data missing for input: ${String(vin.txid)}`);
     return vin.prevout;
 }
 export function parse_txinput(txdata, config) {
     let { txindex, txinput } = config ?? {};
     if (txindex !== undefined) {
         if (txindex >= txdata.vin.length) {
-            throw new Error('Input index out of bounds: ' + String(txindex));
+            throw new Error(`Input index out of bounds: ${String(txindex)}`);
         }
         txinput = txdata.vin.at(txindex);
     }
@@ -22,8 +22,8 @@ export function get_annex_data(witness) {
     if (witness.length < 2)
         return;
     const annex = witness.at(-1);
-    if (typeof annex === 'string' && annex.startsWith('50')) {
-        const bytes = Buff.hex(annex).prefix_varint('be');
+    if (typeof annex === "string" && annex.startsWith("50")) {
+        const bytes = Buff.hex(annex).prefix_varint("be");
         return sha256(bytes);
     }
     return undefined;

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

@@ -1,2 +1,2 @@
-export * from './sign.js';
-export * from './verify.js';
+export * from "./sign.js";
+export * from "./verify.js";

package/dist/lib/signer/index.js

@@ -1,2 +1,2 @@
-export * from './sign.js';
-export * from './verify.js';
+export * from "./sign.js";
+export * from "./verify.js";

package/dist/lib/signer/sign.d.ts

@@ -1,3 +1,3 @@
-import type { SigHashOptions, TxData } from '../../types/index.js';
+import type { SigHashOptions, TxData } from "../../types/index.js";
 export declare function sign_segwit_tx(seckey: string, txdata: TxData, options: SigHashOptions): string;
 export declare function sign_taproot_tx(seckey: string, txdata: TxData, options: SigHashOptions): string;

package/dist/lib/signer/sign.js

@@ -1,10 +1,43 @@
-import { Buff } from '@vbyte/buff';
-import { ECC } from '@vbyte/micro-lib';
-import { parse_tx } from '../../lib/tx/parse.js';
-import { SIGHASH_DEFAULT } from '../../const.js';
-import { hash_segwit_tx } from '../../lib/sighash/segwit.js';
-import { hash_taproot_tx } from '../../lib/sighash/taproot.js';
+import { Buff } from "@vbyte/buff";
+import { ECC } from "@vbyte/micro-lib";
+import { SIGHASH_DEFAULT, SIGHASH_SEGWIT, SIGHASH_TAPROOT } from "../../const.js";
+import { hash_segwit_tx } from "../../lib/sighash/segwit.js";
+import { hash_taproot_tx } from "../../lib/sighash/taproot.js";
+import { parse_tx } from "../../lib/tx/parse.js";
+const SECKEY_REGEX = /^[0-9a-fA-F]{64}$/;
+function validate_seckey(seckey) {
+    if (typeof seckey !== "string") {
+        throw new Error("Secret key must be a string");
+    }
+    if (!SECKEY_REGEX.test(seckey)) {
+        throw new Error("Invalid secret key format: expected 32-byte hex string (64 characters)");
+    }
+}
+function validate_sighash_options(options, validFlags) {
+    const { sigflag, txindex } = options;
+    if (sigflag !== undefined) {
+        if (typeof sigflag !== "number" || !Number.isInteger(sigflag)) {
+            throw new Error("sigflag must be an integer");
+        }
+        const normalizedFlag = sigflag & 0x7f;
+        const isAnypay = (sigflag & 0x80) === 0x80;
+        const baseFlag = isAnypay ? normalizedFlag | 0x80 : normalizedFlag;
+        if (!validFlags.includes(baseFlag) &&
+            !validFlags.includes(normalizedFlag)) {
+            throw new Error(`Invalid sigflag: ${sigflag}`);
+        }
+    }
+    if (txindex !== undefined) {
+        if (typeof txindex !== "number" ||
+            !Number.isInteger(txindex) ||
+            txindex < 0) {
+            throw new Error("txindex must be a non-negative integer");
+        }
+    }
+}
 export function sign_segwit_tx(seckey, txdata, options) {
+    validate_seckey(seckey);
+    validate_sighash_options(options, SIGHASH_SEGWIT);
     const tx = parse_tx(txdata);
     const msg = hash_segwit_tx(tx, options);
     const sig = ECC.sign_ecdsa(seckey, msg).hex;
@@ -12,6 +45,8 @@ export function sign_segwit_tx(seckey, txdata, options) {
     return sig + flag;
 }
 export function sign_taproot_tx(seckey, txdata, options) {
+    validate_seckey(seckey);
+    validate_sighash_options(options, SIGHASH_TAPROOT);
     const tx = parse_tx(txdata);
     const msg = hash_taproot_tx(tx, options);
     const sig = ECC.sign_bip340(seckey, msg).hex;
@@ -19,5 +54,5 @@ export function sign_taproot_tx(seckey, txdata, options) {
     return sig + flag;
 }
 function format_sigflag(flag) {
-    return (flag !== 0) ? Buff.num(flag, 1).hex : '';
+    return flag !== 0 ? Buff.num(flag, 1).hex : "";
 }

package/dist/lib/signer/verify.d.ts

@@ -1,3 +1,17 @@
-import { Bytes } from '@vbyte/buff';
-import type { SigHashOptions, TxData } from '../../types/index.js';
-export declare function verify_tx(_txdata: TxData | Bytes, _config?: SigHashOptions): boolean;
+import { type Bytes } from "@vbyte/buff";
+import type { SigHashOptions, TxData } from "../../types/index.js";
+export interface VerifyOptions extends SigHashOptions {
+    throws?: boolean;
+}
+export interface VerifyResult {
+    valid: boolean;
+    inputs: InputVerifyResult[];
+    error?: string;
+}
+export interface InputVerifyResult {
+    index: number;
+    valid: boolean;
+    type?: string | null;
+    error?: string;
+}
+export declare function verify_tx(txdata: TxData | Bytes, options?: VerifyOptions): VerifyResult;