@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/psbt/psbtutils.d.ts

@@ -1,64 +0,0 @@
-/// <reference types="node" />
-import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces';
-export declare const isP2MS: (script: Buffer) => boolean;
-export declare const isP2PK: (script: Buffer) => boolean;
-export declare const isP2PKH: (script: Buffer) => boolean;
-export declare const isP2WPKH: (script: Buffer) => boolean;
-export declare const isP2WSHScript: (script: Buffer) => boolean;
-export declare const isP2SHScript: (script: Buffer) => boolean;
-export declare const isP2TR: (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.
- */
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The converted script witness.
- */
-export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
-/**
- * Finds the position of a public key in a script.
- * @param pubkey The public key to search for.
- * @param script The script to search in.
- * @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 declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
-/**
- * Checks if a public key is present in a script.
- * @param pubkey The public key to check.
- * @param script The script to search in.
- * @returns A boolean indicating whether the public key is present in the script.
- */
-export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;
-/**
- * Checks if an input contains a signature for a specific action.
- * @param input - The input to check.
- * @param action - The action to check for.
- * @returns A boolean indicating whether the input contains a signature for the specified action.
- */
-export declare function checkInputForSig(input: PsbtInput, action: string): boolean;
-type SignatureDecodeFunc = (buffer: Buffer) => {
-    signature: Buffer;
-    hashType: number;
-};
-/**
- * Determines if a given action is allowed for a signature block.
- * @param signature - The signature block.
- * @param signatureDecodeFn - The function used to decode the signature.
- * @param action - The action to be checked.
- * @returns True if the action is allowed, false otherwise.
- */
-export declare function signatureBlocksAction(signature: Buffer, signatureDecodeFn: SignatureDecodeFunc, action: string): boolean;
-/**
- * Retrieves the partial signatures (Psigs) from the input's final scripts.
- * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
- * Only canonical script signatures are considered.
- *
- * @param input - The PsbtInput object representing the input.
- * @returns An array of PartialSig objects containing the extracted Psigs.
- */
-export declare function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[];
-export {};

package/src/psbt/psbtutils.js

@@ -1,191 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getPsigsFromInputFinalScripts =
-    exports.signatureBlocksAction =
-    exports.checkInputForSig =
-    exports.pubkeyInScript =
-    exports.pubkeyPositionInScript =
-    exports.witnessStackToScriptWitness =
-    exports.isP2TR =
-    exports.isP2SHScript =
-    exports.isP2WSHScript =
-    exports.isP2WPKH =
-    exports.isP2PKH =
-    exports.isP2PK =
-    exports.isP2MS =
-        void 0;
-const varuint = require('bip174/src/lib/converter/varint');
-const bscript = require('../script');
-const transaction_1 = require('../transaction');
-const crypto_1 = require('../crypto');
-const payments = require('../payments');
-function isPaymentFactory(payment) {
-    return script => {
-        try {
-            payment({ output: script });
-            return true;
-        } catch (err) {
-            return false;
-        }
-    };
-}
-exports.isP2MS = isPaymentFactory(payments.p2ms);
-exports.isP2PK = isPaymentFactory(payments.p2pk);
-exports.isP2PKH = isPaymentFactory(payments.p2pkh);
-exports.isP2WPKH = isPaymentFactory(payments.p2wpkh);
-exports.isP2WSHScript = isPaymentFactory(payments.p2wsh);
-exports.isP2SHScript = isPaymentFactory(payments.p2sh);
-exports.isP2TR = isPaymentFactory(payments.p2tr);
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The script witness as a Buffer.
- */
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The converted script witness.
- */
-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;
-}
-exports.witnessStackToScriptWitness = witnessStackToScriptWitness;
-/**
- * Finds the position of a public key in a script.
- * @param pubkey The public key to search for.
- * @param script The script to search in.
- * @returns The index of the public key in the script, or -1 if not found.
- * @throws {Error} If there is an unknown script error.
- */
-function pubkeyPositionInScript(pubkey, script) {
-    const pubkeyHash = (0, crypto_1.hash160)(pubkey);
-    const pubkeyXOnly = pubkey.slice(1, 33); // slice before calling?
-    const decompiled = bscript.decompile(script);
-    if (decompiled === null) throw new Error('Unknown script error');
-    return decompiled.findIndex(element => {
-        if (typeof element === 'number') return false;
-        return (
-            element.equals(pubkey) ||
-            element.equals(pubkeyHash) ||
-            element.equals(pubkeyXOnly)
-        );
-    });
-}
-exports.pubkeyPositionInScript = pubkeyPositionInScript;
-/**
- * Checks if a public key is present in a script.
- * @param pubkey The public key to check.
- * @param script The script to search in.
- * @returns A boolean indicating whether the public key is present in the script.
- */
-function pubkeyInScript(pubkey, script) {
-    return pubkeyPositionInScript(pubkey, script) !== -1;
-}
-exports.pubkeyInScript = pubkeyInScript;
-/**
- * Checks if an input contains a signature for a specific action.
- * @param input - The input to check.
- * @param action - The action to check for.
- * @returns A boolean indicating whether the input contains a signature for the specified action.
- */
-function checkInputForSig(input, action) {
-    const pSigs = extractPartialSigs(input);
-    return pSigs.some(pSig =>
-        signatureBlocksAction(pSig, bscript.signature.decode, action),
-    );
-}
-exports.checkInputForSig = checkInputForSig;
-/**
- * Determines if a given action is allowed for a signature block.
- * @param signature - The signature block.
- * @param signatureDecodeFn - The function used to decode the signature.
- * @param action - The action to be checked.
- * @returns True if the action is allowed, false otherwise.
- */
-function signatureBlocksAction(signature, signatureDecodeFn, action) {
-    const { hashType } = signatureDecodeFn(signature);
-    const whitelist = [];
-    const isAnyoneCanPay =
-        hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY;
-    if (isAnyoneCanPay) whitelist.push('addInput');
-    const hashMod = hashType & 0x1f;
-    switch (hashMod) {
-        case transaction_1.Transaction.SIGHASH_ALL:
-            break;
-        case transaction_1.Transaction.SIGHASH_SINGLE:
-        case transaction_1.Transaction.SIGHASH_NONE:
-            whitelist.push('addOutput');
-            whitelist.push('setInputSequence');
-            break;
-    }
-    if (whitelist.indexOf(action) === -1) {
-        return true;
-    }
-    return false;
-}
-exports.signatureBlocksAction = signatureBlocksAction;
-/**
- * Extracts the signatures from a PsbtInput object.
- * If the input has partial signatures, it returns an array of the signatures.
- * If the input does not have partial signatures, it checks if it has a finalScriptSig or finalScriptWitness.
- * If it does, it extracts the signatures from the final scripts and returns them.
- * If none of the above conditions are met, it returns an empty array.
- *
- * @param input - The PsbtInput object from which to extract the signatures.
- * @returns An array of signatures extracted from the PsbtInput object.
- */
-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);
-}
-/**
- * Retrieves the partial signatures (Psigs) from the input's final scripts.
- * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
- * Only canonical script signatures are considered.
- *
- * @param input - The PsbtInput object representing the input.
- * @returns An array of PartialSig objects containing the extracted Psigs.
- */
-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 }));
-}
-exports.getPsigsFromInputFinalScripts = getPsigsFromInputFinalScripts;

package/src/push_data.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-/**
- * Calculates the encoding length of a number used for push data in Bitcoin transactions.
- * @param i The number to calculate the encoding length for.
- * @returns The encoding length of the number.
- */
-export declare function encodingLength(i: number): number;
-/**
- * Encodes a number into a buffer using a variable-length encoding scheme.
- * The encoded buffer is written starting at the specified offset.
- * Returns the size of the encoded buffer.
- *
- * @param buffer - The buffer to write the encoded data into.
- * @param num - The number to encode.
- * @param offset - The offset at which to start writing the encoded buffer.
- * @returns The size of the encoded buffer.
- */
-export declare function encode(buffer: Buffer, num: number, offset: number): number;
-/**
- * Decodes a buffer and returns information about the opcode, number, and size.
- * @param buffer - The buffer to decode.
- * @param offset - The offset within the buffer to start decoding.
- * @returns An object containing the opcode, number, and size, or null if decoding fails.
- */
-export declare function decode(buffer: Buffer, offset: number): {
-    opcode: number;
-    number: number;
-    size: number;
-} | null;

package/src/script.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import { OPS } from './ops';
-import { Stack } from './payments';
-import * as scriptNumber from './script_number';
-import * as scriptSignature from './script_signature';
-export { OPS };
-export declare function isPushOnly(value: Stack): boolean;
-export declare function countNonPushOnlyOPs(value: Stack): number;
-/**
- * Compiles an array of chunks into a Buffer.
- *
- * @param chunks - The array of chunks to compile.
- * @returns The compiled Buffer.
- * @throws Error if the compilation fails.
- */
-export declare function compile(chunks: Buffer | Stack): Buffer;
-export declare function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null;
-/**
- * Converts the given chunks into an ASM (Assembly) string representation.
- * If the chunks parameter is a Buffer, it will be decompiled into a Stack before conversion.
- * @param chunks - The chunks to convert into ASM.
- * @returns The ASM string representation of the chunks.
- */
-export declare function toASM(chunks: Buffer | Array<number | Buffer>): string;
-/**
- * Converts an ASM string to a Buffer.
- * @param asm The ASM string to convert.
- * @returns The converted Buffer.
- */
-export declare function fromASM(asm: string): Buffer;
-/**
- * Converts the given chunks into a stack of buffers.
- *
- * @param chunks - The chunks to convert.
- * @returns The stack of buffers.
- */
-export declare function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[];
-export declare function isCanonicalPubKey(buffer: Buffer): boolean;
-export declare function isDefinedHashType(hashType: number): boolean;
-export declare function isCanonicalScriptSignature(buffer: Buffer): boolean;
-export declare const number: typeof scriptNumber;
-export declare const signature: typeof scriptSignature;

package/src/script_number.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="node" />
-/**
- * Decodes a script number from a buffer.
- *
- * @param buffer - The buffer containing the script number.
- * @param maxLength - The maximum length of the script number. Defaults to 4.
- * @param minimal - Whether the script number should be minimal. Defaults to true.
- * @returns The decoded script number.
- * @throws {TypeError} If the script number overflows the maximum length.
- * @throws {Error} If the script number is not minimally encoded when minimal is true.
- */
-export declare function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number;
-/**
- * Encodes a number into a Buffer using a specific format.
- *
- * @param _number - The number to encode.
- * @returns The encoded number as a Buffer.
- */
-export declare function encode(_number: number): Buffer;

package/src/script_signature.d.ts

@@ -1,21 +0,0 @@
-/// <reference types="node" />
-interface ScriptSignature {
-    signature: Buffer;
-    hashType: number;
-}
-/**
- * Decodes a buffer into a ScriptSignature object.
- * @param buffer - The buffer to decode.
- * @returns The decoded ScriptSignature object.
- * @throws Error if the hashType is invalid.
- */
-export declare function decode(buffer: Buffer): ScriptSignature;
-/**
- * Encodes a signature and hash type into a buffer.
- * @param signature - The signature to encode.
- * @param hashType - The hash type to encode.
- * @returns The encoded buffer.
- * @throws Error if the hashType is invalid.
- */
-export declare function encode(signature: Buffer, hashType: number): Buffer;
-export {};

package/src/types.js

@@ -1,106 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.oneOf =
-    exports.Null =
-    exports.BufferN =
-    exports.Function =
-    exports.UInt32 =
-    exports.UInt8 =
-    exports.tuple =
-    exports.maybe =
-    exports.Hex =
-    exports.Buffer =
-    exports.String =
-    exports.Boolean =
-    exports.Array =
-    exports.Number =
-    exports.Hash256bit =
-    exports.Hash160bit =
-    exports.Buffer256bit =
-    exports.isTaptree =
-    exports.isTapleaf =
-    exports.TAPLEAF_VERSION_MASK =
-    exports.Satoshi =
-    exports.isPoint =
-    exports.stacksEqual =
-    exports.typeforce =
-        void 0;
-const buffer_1 = require('buffer');
-exports.typeforce = require('typeforce');
-const ZERO32 = buffer_1.Buffer.alloc(32, 0);
-const EC_P = buffer_1.Buffer.from(
-    'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
-    'hex',
-);
-/**
- * Checks if two arrays of Buffers are equal.
- * @param a - The first array of Buffers.
- * @param b - The second array of Buffers.
- * @returns True if the arrays are equal, false otherwise.
- */
-function stacksEqual(a, b) {
-    if (a.length !== b.length) return false;
-    return a.every((x, i) => {
-        return x.equals(b[i]);
-    });
-}
-exports.stacksEqual = stacksEqual;
-/**
- * Checks if the given value is a valid elliptic curve point.
- * @param p - The value to check.
- * @returns True if the value is a valid elliptic curve point, false otherwise.
- */
-function isPoint(p) {
-    if (!buffer_1.Buffer.isBuffer(p)) return false;
-    if (p.length < 33) return false;
-    const t = p[0];
-    const x = p.slice(1, 33);
-    if (x.compare(ZERO32) === 0) return false;
-    if (x.compare(EC_P) >= 0) return false;
-    if ((t === 0x02 || t === 0x03) && p.length === 33) {
-        return true;
-    }
-    const y = p.slice(33);
-    if (y.compare(ZERO32) === 0) return false;
-    if (y.compare(EC_P) >= 0) return false;
-    if (t === 0x04 && p.length === 65) return true;
-    return false;
-}
-exports.isPoint = isPoint;
-const SATOSHI_MAX = 21 * 1e14;
-function Satoshi(value) {
-    return exports.typeforce.UInt53(value) && value <= SATOSHI_MAX;
-}
-exports.Satoshi = Satoshi;
-exports.TAPLEAF_VERSION_MASK = 0xfe;
-function isTapleaf(o) {
-    if (!o || !('output' in o)) return false;
-    if (!buffer_1.Buffer.isBuffer(o.output)) return false;
-    if (o.version !== undefined)
-        return (o.version & exports.TAPLEAF_VERSION_MASK) === o.version;
-    return true;
-}
-exports.isTapleaf = isTapleaf;
-function isTaptree(scriptTree) {
-    if (!(0, exports.Array)(scriptTree)) return isTapleaf(scriptTree);
-    if (scriptTree.length !== 2) return false;
-    return scriptTree.every(t => isTaptree(t));
-}
-exports.isTaptree = isTaptree;
-exports.Buffer256bit = exports.typeforce.BufferN(32);
-exports.Hash160bit = exports.typeforce.BufferN(20);
-exports.Hash256bit = exports.typeforce.BufferN(32);
-exports.Number = exports.typeforce.Number;
-exports.Array = exports.typeforce.Array;
-exports.Boolean = exports.typeforce.Boolean;
-exports.String = exports.typeforce.String;
-exports.Buffer = exports.typeforce.Buffer;
-exports.Hex = exports.typeforce.Hex;
-exports.maybe = exports.typeforce.maybe;
-exports.tuple = exports.typeforce.tuple;
-exports.UInt8 = exports.typeforce.UInt8;
-exports.UInt32 = exports.typeforce.UInt32;
-exports.Function = exports.typeforce.Function;
-exports.BufferN = exports.typeforce.BufferN;
-exports.Null = exports.typeforce.Null;
-exports.oneOf = exports.typeforce.oneOf;