@btc-vision/bitcoin 6.3.1 → 6.3.3

package/build/psbt/psbtutils.js

@@ -0,0 +1,177 @@
+import { ProjectivePoint } from '@noble/secp256k1';
+import * as varuint from 'bip174/src/lib/converter/varint.js';
+import { hash160 } from '../crypto.js';
+import { p2ms } from '../payments/p2ms.js';
+import { p2pk } from '../payments/p2pk.js';
+import { p2pkh } from '../payments/p2pkh.js';
+import { p2sh } from '../payments/p2sh.js';
+import { p2tr } from '../payments/p2tr.js';
+import { p2wpkh } from '../payments/p2wpkh.js';
+import { p2wsh } from '../payments/p2wsh.js';
+import * as bscript from '../script.js';
+import { Transaction } from '../transaction.js';
+import { toXOnly } from './bip371.js';
+function isPaymentFactory(payment) {
+    return (script) => {
+        try {
+            payment({ output: script });
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    };
+}
+export const isP2MS = isPaymentFactory(p2ms);
+export const isP2PK = isPaymentFactory(p2pk);
+export const isP2PKH = isPaymentFactory(p2pkh);
+export const isP2WPKH = isPaymentFactory(p2wpkh);
+export const isP2WSHScript = isPaymentFactory(p2wsh);
+export const isP2SHScript = isPaymentFactory(p2sh);
+export const isP2TR = isPaymentFactory(p2tr);
+export function witnessStackToScriptWitness(witness) {
+    let buffer = Buffer.allocUnsafe(0);
+    function writeSlice(slice) {
+        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    }
+    function writeVarInt(i) {
+        const currentLen = buffer.length;
+        const varintLen = varuint.encodingLength(i);
+        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+        varuint.encode(i, buffer, currentLen);
+    }
+    function writeVarSlice(slice) {
+        writeVarInt(slice.length);
+        writeSlice(slice);
+    }
+    function writeVector(vector) {
+        writeVarInt(vector.length);
+        vector.forEach(writeVarSlice);
+    }
+    writeVector(witness);
+    return buffer;
+}
+export function decompressPublicKey(realPubKey) {
+    if (![33, 65].includes(realPubKey.length)) {
+        throw new Error(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
+    }
+    let point;
+    try {
+        point = ProjectivePoint.fromHex(realPubKey);
+    }
+    catch (err) {
+        throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
+    }
+    const xBuf = bigIntTo32Bytes(point.x);
+    const yBuf = bigIntTo32Bytes(point.y);
+    const isEven = point.y % 2n === 0n;
+    const prefix = isEven ? 0x06 : 0x07;
+    const hybridPubKey = Buffer.alloc(65);
+    hybridPubKey[0] = prefix;
+    xBuf.copy(hybridPubKey, 1);
+    yBuf.copy(hybridPubKey, 33);
+    const uncompressedPubKey = Buffer.concat([Buffer.from([0x04]), xBuf, yBuf]);
+    return {
+        hybrid: hybridPubKey,
+        uncompressed: uncompressedPubKey,
+    };
+}
+export function bigIntTo32Bytes(num) {
+    let hex = num.toString(16);
+    hex = hex.padStart(64, '0');
+    if (hex.length > 64) {
+        hex = hex.slice(-64);
+    }
+    return Buffer.from(hex, 'hex');
+}
+export function pubkeysMatch(a, b) {
+    if (a.equals(b))
+        return true;
+    if (a.length === 65 && b.length === 65) {
+        const aCopy = Buffer.from(a);
+        const bCopy = Buffer.from(b);
+        if (aCopy[0] === 0x06 || aCopy[0] === 0x07)
+            aCopy[0] = 0x04;
+        if (bCopy[0] === 0x06 || bCopy[0] === 0x07)
+            bCopy[0] = 0x04;
+        return aCopy.equals(bCopy);
+    }
+    return false;
+}
+export function pubkeyPositionInScript(pubkey, script) {
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null)
+        throw new Error('Unknown script error');
+    const pubkeyHash = hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+    const uncompressed = decompressPublicKey(pubkey);
+    const pubkeyHybridHash = hash160(uncompressed.hybrid);
+    const pubkeyUncompressedHash = hash160(uncompressed.uncompressed);
+    return decompiled.findIndex((element) => {
+        if (typeof element === 'number')
+            return false;
+        if (pubkeysMatch(element, pubkey))
+            return true;
+        if (pubkeysMatch(element, pubkeyXOnly))
+            return true;
+        if (element.equals(pubkeyHash)) {
+            return true;
+        }
+        if (pubkeysMatch(element, uncompressed.uncompressed))
+            return true;
+        if (pubkeysMatch(element, uncompressed.hybrid))
+            return true;
+        if (element.equals(pubkeyHybridHash) || element.equals(pubkeyUncompressedHash)) {
+            return true;
+        }
+    });
+}
+export function pubkeyInScript(pubkey, script) {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+export function checkInputForSig(input, action) {
+    const pSigs = extractPartialSigs(input);
+    return pSigs.some((pSig) => signatureBlocksAction(pSig, bscript.signature.decode, action));
+}
+export function signatureBlocksAction(signature, signatureDecodeFn, action) {
+    const { hashType } = signatureDecodeFn(signature);
+    const whitelist = [];
+    const isAnyoneCanPay = hashType & Transaction.SIGHASH_ANYONECANPAY;
+    if (isAnyoneCanPay)
+        whitelist.push('addInput');
+    const hashMod = hashType & 0x1f;
+    switch (hashMod) {
+        case Transaction.SIGHASH_ALL:
+            break;
+        case Transaction.SIGHASH_SINGLE:
+        case Transaction.SIGHASH_NONE:
+            whitelist.push('addOutput');
+            whitelist.push('setInputSequence');
+            break;
+    }
+    return whitelist.indexOf(action) === -1;
+}
+function extractPartialSigs(input) {
+    let pSigs = [];
+    if ((input.partialSig || []).length === 0) {
+        if (!input.finalScriptSig && !input.finalScriptWitness)
+            return [];
+        pSigs = getPsigsFromInputFinalScripts(input);
+    }
+    else {
+        pSigs = input.partialSig;
+    }
+    return pSigs.map((p) => p.signature);
+}
+export function getPsigsFromInputFinalScripts(input) {
+    const scriptItems = !input.finalScriptSig ? [] : bscript.decompile(input.finalScriptSig) || [];
+    const witnessItems = !input.finalScriptWitness
+        ? []
+        : bscript.decompile(input.finalScriptWitness) || [];
+    return scriptItems
+        .concat(witnessItems)
+        .filter((item) => {
+        return Buffer.isBuffer(item) && bscript.isCanonicalScriptSignature(item);
+    })
+        .map((sig) => ({ signature: sig }));
+}

package/build/psbt.d.ts

@@ -0,0 +1,167 @@
+import { Psbt as PsbtBase } from 'bip174';
+import { KeyValue, PartialSig, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces.js';
+import { BIP32Interface } from 'bip32';
+import { ECPairInterface } from 'ecpair';
+import { Network } from './networks.js';
+import { Transaction } from './transaction.js';
+export interface TransactionInput {
+    hash: string | Buffer;
+    index: number;
+    sequence?: number;
+}
+export interface PsbtTxInput extends TransactionInput {
+    hash: Buffer;
+}
+export interface TransactionOutput {
+    script: Buffer;
+    value: number;
+}
+export interface PsbtTxOutput extends TransactionOutput {
+    address: string | undefined;
+}
+export type ValidateSigFunction = (pubkey: Buffer, msghash: Buffer, signature: Buffer) => boolean;
+export interface PsbtBaseExtended extends Omit<PsbtBase, 'inputs'> {
+    inputs: PsbtInput[];
+    globalMap: PsbtGlobal;
+}
+export declare class Psbt {
+    data: PsbtBaseExtended;
+    private readonly __CACHE;
+    private readonly opts;
+    constructor(opts?: PsbtOptsOptional, data?: PsbtBaseExtended);
+    get inputCount(): number;
+    get version(): number;
+    set version(version: number);
+    get locktime(): number;
+    set locktime(locktime: number);
+    get txInputs(): PsbtTxInput[];
+    get txOutputs(): PsbtTxOutput[];
+    static fromBase64(data: string, opts?: PsbtOptsOptional): Psbt;
+    static fromHex(data: string, opts?: PsbtOptsOptional): Psbt;
+    static fromBuffer(buffer: Buffer, opts?: PsbtOptsOptional): Psbt;
+    combine(...those: Psbt[]): this;
+    clone(): Psbt;
+    setMaximumFeeRate(satoshiPerByte: number): void;
+    setVersion(version: number): this;
+    setLocktime(locktime: number): this;
+    setInputSequence(inputIndex: number, sequence: number): this;
+    addInputs(inputDatas: PsbtInputExtended[], checkPartialSigs?: boolean): this;
+    addInput(inputData: PsbtInputExtended, checkPartialSigs?: boolean): this;
+    addOutputs(outputDatas: PsbtOutputExtended[]): this;
+    addOutput(outputData: PsbtOutputExtended): this;
+    extractTransaction(disableFeeCheck?: boolean, disableOutputChecks?: boolean): Transaction;
+    getFeeRate(disableOutputChecks?: boolean): number;
+    getFee(disableOutputChecks?: boolean): number;
+    finalizeAllInputs(): this;
+    finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc, canRunChecks?: boolean): this;
+    finalizeTaprootInput(inputIndex: number, tapLeafHashToFinalize?: Buffer, finalScriptsFunc?: FinalTaprootScriptsFunc): this;
+    getInputType(inputIndex: number): AllScriptType;
+    inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean;
+    inputHasHDKey(inputIndex: number, root: HDSigner): boolean;
+    outputHasPubkey(outputIndex: number, pubkey: Buffer): boolean;
+    outputHasHDKey(outputIndex: number, root: HDSigner): boolean;
+    validateSignaturesOfAllInputs(validator: ValidateSigFunction): boolean;
+    validateSignaturesOfInput(inputIndex: number, validator: ValidateSigFunction, pubkey?: Buffer): boolean;
+    signAllInputsHD(hdKeyPair: HDSigner, sighashTypes?: number[]): this;
+    signAllInputsHDAsync(hdKeyPair: HDSigner | HDSignerAsync, sighashTypes?: number[]): Promise<void>;
+    signInputHD(inputIndex: number, hdKeyPair: HDSigner, sighashTypes?: number[]): this;
+    signInputHDAsync(inputIndex: number, hdKeyPair: HDSigner | HDSignerAsync, sighashTypes?: number[]): Promise<void>;
+    signAllInputs(keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface, sighashTypes?: number[]): this;
+    signAllInputsAsync(keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface, sighashTypes?: number[]): Promise<void>;
+    signInput(inputIndex: number, keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface, sighashTypes?: number[]): this;
+    signTaprootInput(inputIndex: number, keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface, tapLeafHashToSign?: Buffer, sighashTypes?: number[]): this;
+    signInputAsync(inputIndex: number, keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface, sighashTypes?: number[]): Promise<void>;
+    signTaprootInputAsync(inputIndex: number, keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface, tapLeafHash?: Buffer, sighashTypes?: number[]): Promise<void>;
+    toBuffer(): Buffer;
+    toHex(): string;
+    toBase64(): string;
+    updateGlobal(updateData: PsbtGlobalUpdate): this;
+    updateInput(inputIndex: number, updateData: PsbtInputUpdate): this;
+    updateOutput(outputIndex: number, updateData: PsbtOutputUpdate): this;
+    addUnknownKeyValToGlobal(keyVal: KeyValue): this;
+    addUnknownKeyValToInput(inputIndex: number, keyVal: KeyValue): this;
+    addUnknownKeyValToOutput(outputIndex: number, keyVal: KeyValue): this;
+    clearFinalizedInput(inputIndex: number): this;
+    checkTaprootHashesForSig(inputIndex: number, input: PsbtInput, keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface, tapLeafHashToSign?: Buffer, allowedSighashTypes?: number[]): {
+        hash: Buffer;
+        leafHash?: Buffer;
+    }[];
+    private _finalizeInput;
+    private _finalizeTaprootInput;
+    private _validateSignaturesOfInput;
+    private validateSignaturesOfTaprootInput;
+    private _signInput;
+    private _signTaprootInput;
+    private _signInputAsync;
+    private _signTaprootInputAsync;
+}
+export interface PsbtOptsOptional {
+    network?: Network;
+    maximumFeeRate?: number;
+}
+export interface PsbtOpts {
+    network: Network;
+    maximumFeeRate: number;
+}
+export interface PsbtInputExtended extends PsbtInput, TransactionInput {
+}
+export type PsbtOutputExtended = PsbtOutputExtendedAddress | PsbtOutputExtendedScript;
+export interface PsbtOutputExtendedAddress extends PsbtOutput {
+    address: string;
+    value: number;
+}
+export interface PsbtOutputExtendedScript extends PsbtOutput {
+    script: Buffer;
+    value: number;
+}
+interface HDSignerBase {
+    publicKey: Buffer;
+    fingerprint: Buffer;
+}
+export interface HDSigner extends HDSignerBase {
+    derivePath(path: string): HDSigner;
+    sign(hash: Buffer): Buffer;
+}
+export interface HDSignerAsync extends HDSignerBase {
+    derivePath(path: string): HDSignerAsync;
+    sign(hash: Buffer): Promise<Buffer>;
+}
+export interface SignerAlternative {
+    publicKey: Buffer;
+    lowR: boolean;
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+    verify(hash: Buffer, signature: Buffer): boolean;
+    signSchnorr(hash: Buffer): Buffer;
+    verifySchnorr(hash: Buffer, signature: Buffer): boolean;
+}
+export interface Signer {
+    publicKey: Buffer;
+    network?: Network;
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+    signSchnorr?(hash: Buffer): Buffer;
+    getPublicKey?(): Buffer;
+}
+export interface SignerAsync {
+    publicKey: Buffer;
+    network?: Network;
+    sign(hash: Buffer, lowR?: boolean): Promise<Buffer>;
+    signSchnorr?(hash: Buffer): Promise<Buffer>;
+    getPublicKey?(): Buffer;
+}
+type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks: boolean) => {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+};
+type FinalTaprootScriptsFunc = (inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer) => {
+    finalScriptWitness: Buffer | undefined;
+};
+export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean): {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+};
+export declare function prepareFinalScripts(script: Buffer, scriptType: string, partialSig: PartialSig[], isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean): {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+};
+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';
+export {};