@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/src/psbt/psbtutils.ts

@@ -1,5 +1,5 @@
-import * as varuint from 'bip174/src/lib/converter/varint.js';
-import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces.js';
+import type { PartialSig, PsbtInput } from 'bip174';
+import { varuint, concat, alloc, equals } from '../io/index.js';
 import { hash160 } from '../crypto.js';
 import { p2ms } from '../payments/p2ms.js';
 import { p2pk } from '../payments/p2pk.js';
@@ -12,13 +12,14 @@ import { p2op } from '../payments/p2op.js';
 import { decompressPublicKey, pubkeysMatch, toXOnly } from '../pubkey.js';
 import * as bscript from '../script.js';
 import { Transaction } from '../transaction.js';
+import type { PublicKey, Script } from '../types.js';
 
-type PaymentFunction = (opts: { output: Buffer }) => unknown;
+type PaymentFunction = (opts: { output: Script }) => unknown;
 
-function isPaymentFactory(payment: PaymentFunction): (script: Buffer) => boolean {
-    return (script: Buffer): boolean => {
+function isPaymentFactory(payment: PaymentFunction): (script: Uint8Array) => boolean {
+    return (script: Uint8Array): boolean => {
         try {
-            payment({ output: script });
+            payment({ output: script as Script });
             return true;
         } catch {
             return false;
@@ -34,7 +35,7 @@ export const isP2WSHScript = isPaymentFactory(p2wsh);
 export const isP2SHScript = isPaymentFactory(p2sh);
 export const isP2TR = isPaymentFactory(p2tr);
 export const isP2OP = isPaymentFactory(p2op);
-export const isP2A = (script: Buffer): boolean => {
+export const isP2A = (script: Uint8Array): boolean => {
     return (
         script.length === 4 &&
         script[0] === 0x51 && // OP_1
@@ -47,41 +48,35 @@ export const isP2A = (script: Buffer): boolean => {
 /**
  * Converts a witness stack to a script witness.
  * @param witness The witness stack to convert.
- * @returns The script witness as a Buffer.
+ * @returns The script witness as a Uint8Array.
  */
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The converted script witness.
- */
-export function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
-    let buffer = Buffer.allocUnsafe(0);
+export function witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array {
+    const chunks: Uint8Array[] = [];
 
-    function writeSlice(slice: Buffer): void {
-        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    function writeSlice(slice: Uint8Array): void {
+        chunks.push(slice);
     }
 
     function writeVarInt(i: number): void {
-        const currentLen = buffer.length;
         const varintLen = varuint.encodingLength(i);
-
-        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        varuint.encode(i, buffer, currentLen);
+        const buf = alloc(varintLen);
+        varuint.encode(i, buf, 0);
+        chunks.push(buf);
     }
 
-    function writeVarSlice(slice: Buffer): void {
+    function writeVarSlice(slice: Uint8Array): void {
         writeVarInt(slice.length);
         writeSlice(slice);
     }
 
-    function writeVector(vector: Buffer[]): void {
+    function writeVector(vector: Uint8Array[]): void {
         writeVarInt(vector.length);
         vector.forEach(writeVarSlice);
     }
 
     writeVector(witness);
 
-    return buffer;
+    return concat(chunks);
 }
 
 /**
@@ -91,7 +86,7 @@ export function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
  * @returns The index of the public key in the script, or -1 if not found.
  * @throws {Error} If there is an unknown script error.
  */
-export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+export function pubkeyPositionInScript(pubkey: Uint8Array, script: Uint8Array): number {
     const decompiled = bscript.decompile(script);
     if (decompiled === null) throw new Error('Unknown script error');
 
@@ -99,8 +94,8 @@ export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
     const pubkeyHash = hash160(pubkey);
 
     // For Taproot or some cases, we might also check the x-only
-    const pubkeyXOnly = toXOnly(pubkey);
-    const uncompressed = decompressPublicKey(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey as PublicKey);
+    const uncompressed = decompressPublicKey(pubkey as PublicKey);
 
     const pubkeyHybridHash = uncompressed?.hybrid ? hash160(uncompressed.hybrid) : undefined;
     const pubkeyUncompressedHash = uncompressed?.uncompressed
@@ -114,7 +109,7 @@ export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
 
         if (pubkeysMatch(element, pubkeyXOnly)) return true;
 
-        if (element.equals(pubkeyHash)) {
+        if (equals(element, pubkeyHash)) {
             return true;
         }
 
@@ -124,12 +119,14 @@ export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
             if (pubkeysMatch(element, uncompressed.hybrid)) return true;
 
             if (
-                (pubkeyHybridHash && element.equals(pubkeyHybridHash)) ||
-                (pubkeyUncompressedHash && element.equals(pubkeyUncompressedHash))
+                (pubkeyHybridHash && equals(element, pubkeyHybridHash)) ||
+                (pubkeyUncompressedHash && equals(element, pubkeyUncompressedHash))
             ) {
                 return true;
             }
         }
+
+        return false;
     });
 }
 
@@ -139,7 +136,7 @@ export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
  * @param script The script to search in.
  * @returns A boolean indicating whether the public key is present in the script.
  */
-export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+export function pubkeyInScript(pubkey: Uint8Array, script: Uint8Array): boolean {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }
 
@@ -154,8 +151,8 @@ export function checkInputForSig(input: PsbtInput, action: string): boolean {
     return pSigs.some((pSig) => signatureBlocksAction(pSig, bscript.signature.decode, action));
 }
 
-type SignatureDecodeFunc = (buffer: Buffer) => {
-    signature: Buffer;
+type SignatureDecodeFunc = (buffer: Uint8Array) => {
+    signature: Uint8Array;
     hashType: number;
 };
 
@@ -167,7 +164,7 @@ type SignatureDecodeFunc = (buffer: Buffer) => {
  * @returns True if the action is allowed, false otherwise.
  */
 export function signatureBlocksAction(
-    signature: Buffer,
+    signature: Uint8Array,
     signatureDecodeFn: SignatureDecodeFunc,
     action: string,
 ): boolean {
@@ -198,7 +195,7 @@ export function signatureBlocksAction(
  * @param input - The PsbtInput object from which to extract the signatures.
  * @returns An array of signatures extracted from the PsbtInput object.
  */
-function extractPartialSigs(input: PsbtInput): Buffer[] {
+function extractPartialSigs(input: PsbtInput): Uint8Array[] {
     const { partialSig } = input;
     let pSigs: PartialSig[];
     if (!partialSig || partialSig.length === 0) {
@@ -207,7 +204,7 @@ function extractPartialSigs(input: PsbtInput): Buffer[] {
     } else {
         pSigs = partialSig;
     }
-    return pSigs.map((p) => p.signature);
+    return pSigs.map((p) => new Uint8Array(p.signature));
 }
 
 /**
@@ -219,14 +216,16 @@ function extractPartialSigs(input: PsbtInput): Buffer[] {
  * @returns An array of PartialSig objects containing the extracted Psigs.
  */
 export function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[] {
-    const scriptItems = !input.finalScriptSig ? [] : bscript.decompile(input.finalScriptSig) || [];
+    const scriptItems = !input.finalScriptSig
+        ? []
+        : bscript.decompile(new Uint8Array(input.finalScriptSig)) || [];
     const witnessItems = !input.finalScriptWitness
         ? []
-        : bscript.decompile(input.finalScriptWitness) || [];
+        : bscript.decompile(new Uint8Array(input.finalScriptWitness)) || [];
     return scriptItems
         .concat(witnessItems)
         .filter((item) => {
-            return Buffer.isBuffer(item) && bscript.isCanonicalScriptSignature(item);
+            return item instanceof Uint8Array && bscript.isCanonicalScriptSignature(item);
         })
-        .map((sig) => ({ signature: sig })) as PartialSig[];
+        .map((sig) => ({ signature: sig as Uint8Array })) as PartialSig[];
 }

package/src/psbt/types.ts

@@ -0,0 +1,331 @@
+/**
+ * PSBT types and interfaces
+ * @packageDocumentation
+ */
+
+import type { Psbt as PsbtBase, PsbtGlobal, PsbtInput, PsbtOutput } from 'bip174';
+import type { Network } from '../networks.js';
+import type { Transaction, TaprootHashCache } from '../transaction.js';
+import type {
+    Bytes32,
+    PublicKey,
+    Satoshi,
+    Script,
+    Signature,
+    SchnorrSignature,
+} from '../types.js';
+
+/**
+ * Transaction input interface for PSBT.
+ */
+export interface TransactionInput {
+    readonly hash: string | Bytes32;
+    readonly index: number;
+    readonly sequence?: number | undefined;
+}
+
+/**
+ * PSBT transaction input with Uint8Array hash.
+ */
+export interface PsbtTxInput extends TransactionInput {
+    readonly hash: Bytes32;
+}
+
+/**
+ * Transaction output interface for PSBT.
+ */
+export interface TransactionOutput {
+    readonly script: Script;
+    readonly value: Satoshi;
+}
+
+/**
+ * PSBT transaction output with optional address.
+ */
+export interface PsbtTxOutput extends TransactionOutput {
+    readonly address: string | undefined;
+}
+
+/**
+ * Signature validation function type.
+ * msghash is 32 byte hash of preimage, signature is 64 byte compact signature (r,s 32 bytes each)
+ */
+export type ValidateSigFunction = (
+    pubkey: PublicKey,
+    msghash: Bytes32,
+    signature: Uint8Array,
+) => boolean;
+
+/**
+ * Extended PsbtBase interface with typed inputs and globalMap.
+ */
+export interface PsbtBaseExtended extends Omit<PsbtBase, 'inputs'> {
+    readonly inputs: PsbtInput[];
+    readonly globalMap: PsbtGlobal;
+}
+
+/**
+ * Optional PSBT options.
+ */
+export interface PsbtOptsOptional {
+    readonly network?: Network | undefined;
+    readonly maximumFeeRate?: number | undefined;
+    readonly version?: 1 | 2 | 3 | undefined;
+}
+
+/**
+ * Required PSBT options.
+ */
+export interface PsbtOpts {
+    readonly network: Network;
+    maximumFeeRate: number;
+}
+
+/**
+ * Extended PSBT input with additional fields.
+ */
+export interface PsbtInputExtended extends PsbtInput, TransactionInput {
+    readonly isPayToAnchor?: boolean | undefined;
+}
+
+/**
+ * Extended PSBT output - either address-based or script-based.
+ */
+export type PsbtOutputExtended = PsbtOutputExtendedAddress | PsbtOutputExtendedScript;
+
+/**
+ * PSBT output with address.
+ */
+export interface PsbtOutputExtendedAddress extends PsbtOutput {
+    readonly address: string;
+    readonly value: Satoshi;
+}
+
+/**
+ * PSBT output with script.
+ */
+export interface PsbtOutputExtendedScript extends PsbtOutput {
+    readonly script: Script;
+    readonly value: Satoshi;
+}
+
+/**
+ * Base interface for HD signers.
+ */
+interface HDSignerBase {
+    /**
+     * DER format compressed publicKey Uint8Array
+     */
+    readonly publicKey: PublicKey;
+    /**
+     * The first 4 bytes of the sha256-ripemd160 of the publicKey
+     */
+    readonly fingerprint: Uint8Array;
+}
+
+/**
+ * HD signer interface for synchronous signing.
+ */
+export interface HDSigner extends HDSignerBase {
+    /**
+     * The path string must match /^m(\/\d+'?)+$/
+     * ex. m/44'/0'/0'/1/23 levels with ' must be hard derivations
+     */
+    derivePath(path: string): HDSigner;
+
+    /**
+     * Input hash (the "message digest") for the signature algorithm
+     * Return a 64 byte signature (32 byte r and 32 byte s in that order)
+     */
+    sign(hash: Bytes32): Uint8Array;
+}
+
+/**
+ * HD signer interface for asynchronous signing.
+ */
+export interface HDSignerAsync extends HDSignerBase {
+    derivePath(path: string): HDSignerAsync;
+
+    sign(hash: Bytes32): Promise<Uint8Array>;
+}
+
+/**
+ * Alternative signer interface with lowR support.
+ */
+export interface SignerAlternative {
+    readonly publicKey: PublicKey;
+    readonly lowR: boolean;
+
+    sign(hash: Bytes32, lowR?: boolean): Signature;
+
+    verify(hash: Bytes32, signature: Signature): boolean;
+
+    signSchnorr(hash: Bytes32): SchnorrSignature;
+
+    verifySchnorr(hash: Bytes32, signature: SchnorrSignature): boolean;
+}
+
+/**
+ * Basic signer interface for synchronous signing.
+ */
+export interface Signer {
+    readonly publicKey: PublicKey;
+    readonly network?: Network | undefined;
+
+    sign(hash: Bytes32, lowR?: boolean): Signature;
+
+    signSchnorr?(hash: Bytes32): SchnorrSignature;
+
+    getPublicKey?(): PublicKey;
+}
+
+/**
+ * Basic signer interface for asynchronous signing.
+ */
+export interface SignerAsync {
+    readonly publicKey: PublicKey;
+    readonly network?: Network | undefined;
+
+    sign(hash: Bytes32, lowR?: boolean): Promise<Signature>;
+
+    signSchnorr?(hash: Bytes32): Promise<SchnorrSignature>;
+
+    getPublicKey?(): PublicKey;
+}
+
+/**
+ * Minimal key pair interface for checking Taproot hashes.
+ * Only requires publicKey and optional signSchnorr presence check.
+ * Used by checkTaprootHashesForSig to accept broader key pair types (e.g., worker key pairs).
+ */
+export interface TaprootHashCheckSigner {
+    readonly publicKey: Uint8Array;
+    signSchnorr?(hash: Uint8Array): Uint8Array | Promise<Uint8Array>;
+}
+
+/**
+ * Internal PSBT cache for computed values.
+ */
+export interface PsbtCache {
+    nonWitnessUtxoTxCache: Transaction[];
+    nonWitnessUtxoBufCache: Uint8Array[];
+    txInCache: TxInCacheMap;
+    tx: Transaction;
+    feeRate?: number | undefined;
+    fee?: number | undefined;
+    extractedTx?: Transaction | undefined;
+    unsafeSignNonSegwit: boolean;
+    /** Cached flag: true if any input has signatures (avoids O(n) check) */
+    hasSignatures: boolean;
+    /** Cached prevOuts for Taproot signing (computed once) */
+    prevOuts?: readonly PrevOut[] | undefined;
+    /** Cached signing scripts */
+    signingScripts?: readonly Script[] | undefined;
+    /** Cached values */
+    values?: readonly Satoshi[] | undefined;
+    /** Cached intermediate hashes for Taproot sighash (computed once per PSBT) */
+    taprootHashCache?: TaprootHashCache | undefined;
+}
+
+/**
+ * Keys for cached numeric values in the transaction cache.
+ */
+export type TxCacheNumberKey = 'feeRate' | 'fee';
+
+/**
+ * Script types for classification.
+ */
+export type ScriptType = 'witnesspubkeyhash' | 'pubkeyhash' | 'multisig' | 'pubkey' | 'nonstandard';
+
+/**
+ * All possible script types including witness types.
+ * Note: P2WPKH can't be wrapped in P2WSH (already a witness program)
+ */
+export type AllScriptType =
+    | 'witnesspubkeyhash'
+    | 'pubkeyhash'
+    | 'multisig'
+    | 'pubkey'
+    | 'nonstandard'
+    | 'p2sh-witnesspubkeyhash'
+    | 'p2sh-pubkeyhash'
+    | 'p2sh-multisig'
+    | 'p2sh-pubkey'
+    | 'p2sh-nonstandard'
+    | 'p2wsh-pubkeyhash'
+    | 'p2wsh-multisig'
+    | 'p2wsh-pubkey'
+    | 'p2wsh-nonstandard'
+    | 'p2sh-p2wsh-pubkeyhash'
+    | 'p2sh-p2wsh-multisig'
+    | 'p2sh-p2wsh-pubkey'
+    | 'p2sh-p2wsh-nonstandard';
+
+/**
+ * Return type for getScriptFromInput function.
+ */
+export interface GetScriptReturn {
+    script: Script | null;
+    isSegwit: boolean;
+    isP2SH: boolean;
+    isP2WSH: boolean;
+}
+
+/**
+ * Index map for transaction input cache.
+ */
+export interface TxInCacheMap {
+    readonly [index: string]: number;
+}
+
+/**
+ * Previous output data for signing.
+ */
+export interface PrevOut {
+    readonly script: Script;
+    readonly value: Satoshi;
+}
+
+/**
+ * Result from getTaprootHashesForSig containing hash and optional leaf hash.
+ */
+export interface TaprootHashResult {
+    readonly hash: Bytes32;
+    readonly leafHash?: Bytes32 | undefined;
+}
+
+/**
+ * Extended Taproot hash result with pubkey for validation.
+ */
+export interface TaprootSigningHash {
+    readonly pubkey: PublicKey;
+    readonly hash: Bytes32;
+    readonly leafHash?: Bytes32 | undefined;
+}
+
+/**
+ * Function type for final scripts computation.
+ */
+export type FinalScriptsFunc = (
+    inputIndex: number,
+    input: PsbtInput,
+    script: Script,
+    isSegwit: boolean,
+    isP2SH: boolean,
+    isP2WSH: boolean,
+    canRunChecks: boolean,
+) => {
+    finalScriptSig: Script | undefined;
+    finalScriptWitness: Uint8Array | undefined;
+};
+
+/**
+ * Function type for final Taproot scripts computation.
+ */
+export type FinalTaprootScriptsFunc = (
+    inputIndex: number,
+    input: PsbtInput,
+    tapLeafHashToFinalize?: Bytes32,
+) => {
+    finalScriptWitness: Uint8Array | undefined;
+};