@btc-vision/bitcoin 6.3.1 → 6.3.2

package/build/payments/p2wsh.js

@@ -0,0 +1,180 @@
+import { bech32 } from 'bech32';
+import * as bcrypto from '../crypto.js';
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+const OPS = bscript.OPS;
+const EMPTY_BUFFER = Buffer.alloc(0);
+function chunkHasUncompressedPubkey(chunk) {
+    if (Buffer.isBuffer(chunk) && chunk.length === 65 && chunk[0] === 0x04 && isPoint(chunk)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function p2wsh(a, opts) {
+    if (!a.address && !a.hash && !a.output && !a.redeem && !a.witness)
+        throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+    typef({
+        network: typef.maybe(typef.Object),
+        address: typef.maybe(typef.String),
+        hash: typef.maybe(typef.BufferN(32)),
+        output: typef.maybe(typef.BufferN(34)),
+        redeem: typef.maybe({
+            input: typef.maybe(typef.Buffer),
+            network: typef.maybe(typef.Object),
+            output: typef.maybe(typef.Buffer),
+            witness: typef.maybe(typef.arrayOf(typef.Buffer)),
+        }),
+        input: typef.maybe(typef.BufferN(0)),
+        witness: typef.maybe(typef.arrayOf(typef.Buffer)),
+    }, a);
+    const _address = lazy.value(() => {
+        const result = bech32.decode(a.address);
+        const version = result.words.shift();
+        const data = bech32.fromWords(result.words);
+        return {
+            version,
+            prefix: result.prefix,
+            data: Buffer.from(data),
+        };
+    });
+    const _rchunks = lazy.value(() => {
+        return bscript.decompile(a.redeem.input);
+    });
+    let network = a.network;
+    if (!network) {
+        network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
+    }
+    const o = { network };
+    lazy.prop(o, 'address', () => {
+        if (!o.hash)
+            return;
+        const words = bech32.toWords(o.hash);
+        words.unshift(0x00);
+        return bech32.encode(network.bech32, words);
+    });
+    lazy.prop(o, 'hash', () => {
+        if (a.output)
+            return a.output.slice(2);
+        if (a.address)
+            return _address().data;
+        if (o.redeem && o.redeem.output)
+            return bcrypto.sha256(o.redeem.output);
+    });
+    lazy.prop(o, 'output', () => {
+        if (!o.hash)
+            return;
+        return bscript.compile([OPS.OP_0, o.hash]);
+    });
+    lazy.prop(o, 'redeem', () => {
+        if (!a.witness)
+            return;
+        return {
+            output: a.witness[a.witness.length - 1],
+            input: EMPTY_BUFFER,
+            witness: a.witness.slice(0, -1),
+        };
+    });
+    lazy.prop(o, 'input', () => {
+        if (!o.witness)
+            return;
+        return EMPTY_BUFFER;
+    });
+    lazy.prop(o, 'witness', () => {
+        if (a.redeem &&
+            a.redeem.input &&
+            a.redeem.input.length > 0 &&
+            a.redeem.output &&
+            a.redeem.output.length > 0) {
+            const stack = bscript.toStack(_rchunks());
+            o.redeem = Object.assign({ witness: stack }, a.redeem);
+            o.redeem.input = EMPTY_BUFFER;
+            return [].concat(stack, a.redeem.output);
+        }
+        if (!a.redeem)
+            return;
+        if (!a.redeem.output)
+            return;
+        if (!a.redeem.witness)
+            return;
+        return [].concat(a.redeem.witness, a.redeem.output);
+    });
+    lazy.prop(o, 'name', () => {
+        const nameParts = ['p2wsh'];
+        if (o.redeem !== undefined && o.redeem.name !== undefined)
+            nameParts.push(o.redeem.name);
+        return nameParts.join('-');
+    });
+    if (opts.validate) {
+        let hash = Buffer.from([]);
+        if (a.address) {
+            if (_address().prefix !== network.bech32)
+                throw new TypeError('Invalid prefix or Network mismatch');
+            if (_address().version !== 0x00)
+                throw new TypeError('Invalid address version');
+            if (_address().data.length !== 32)
+                throw new TypeError('Invalid address data');
+            hash = _address().data;
+        }
+        if (a.hash) {
+            if (hash.length > 0 && !hash.equals(a.hash))
+                throw new TypeError('Hash mismatch');
+            else
+                hash = a.hash;
+        }
+        if (a.output) {
+            if (a.output.length !== 34 || a.output[0] !== OPS.OP_0 || a.output[1] !== 0x20)
+                throw new TypeError('Output is invalid');
+            const hash2 = a.output.slice(2);
+            if (hash.length > 0 && !hash.equals(hash2))
+                throw new TypeError('Hash mismatch');
+            else
+                hash = hash2;
+        }
+        if (a.redeem) {
+            if (a.redeem.network && a.redeem.network !== network)
+                throw new TypeError('Network mismatch');
+            if (a.redeem.input &&
+                a.redeem.input.length > 0 &&
+                a.redeem.witness &&
+                a.redeem.witness.length > 0)
+                throw new TypeError('Ambiguous witness source');
+            if (a.redeem.output) {
+                const decompile = bscript.decompile(a.redeem.output);
+                if (!decompile || decompile.length < 1)
+                    throw new TypeError('Redeem.output is invalid');
+                if (a.redeem.output.byteLength > 3600)
+                    throw new TypeError('Redeem.output unspendable if larger than 3600 bytes');
+                if (bscript.countNonPushOnlyOPs(decompile) > 201)
+                    throw new TypeError('Redeem.output unspendable with more than 201 non-push ops');
+                const hash2 = bcrypto.sha256(a.redeem.output);
+                if (hash.length > 0 && !hash.equals(hash2))
+                    throw new TypeError('Hash mismatch');
+                else
+                    hash = hash2;
+            }
+            if (a.redeem.input && !bscript.isPushOnly(_rchunks()))
+                throw new TypeError('Non push-only scriptSig');
+            if (a.witness && a.redeem.witness && !stacksEqual(a.witness, a.redeem.witness))
+                throw new TypeError('Witness and redeem.witness mismatch');
+            if ((a.redeem.input && _rchunks().some(chunkHasUncompressedPubkey)) ||
+                (a.redeem.output &&
+                    (bscript.decompile(a.redeem.output) || []).some(chunkHasUncompressedPubkey))) {
+                throw new TypeError('redeem.input or redeem.output contains uncompressed pubkey');
+            }
+        }
+        if (a.witness && a.witness.length > 0) {
+            const wScript = a.witness[a.witness.length - 1];
+            if (a.redeem && a.redeem.output && !a.redeem.output.equals(wScript))
+                throw new TypeError('Witness and redeem.output mismatch');
+            if (a.witness.some(chunkHasUncompressedPubkey) ||
+                (bscript.decompile(wScript) || []).some(chunkHasUncompressedPubkey))
+                throw new TypeError('Witness contains uncompressed pubkey');
+        }
+    }
+    return Object.assign(o, a);
+}

package/build/psbt/bip371.d.ts

@@ -0,0 +1,16 @@
+import { PsbtInput, PsbtOutput, TapLeaf } from 'bip174/src/lib/interfaces.js';
+import { Taptree } from '../types.js';
+export declare const toXOnly: (pubKey: Buffer | Uint8Array) => Buffer;
+export declare function tapScriptFinalizer(inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer): {
+    finalScriptWitness: Buffer | undefined;
+};
+export declare function serializeTaprootSignature(sig: Buffer, sighashType?: number): Buffer;
+export declare function isTaprootInput(input: PsbtInput): boolean;
+export declare function isTaprootOutput(output: PsbtOutput, script?: Buffer): boolean;
+export declare function checkTaprootInputFields(inputData: PsbtInput, newInputData: PsbtInput, action: string): void;
+export declare function checkTaprootOutputFields(outputData: PsbtOutput, newOutputData: PsbtOutput, action: string): void;
+export declare function tweakInternalPubKey(inputIndex: number, input: PsbtInput): Buffer;
+export declare function tapTreeToList(tree: Taptree): TapLeaf[];
+export declare function tapTreeFromList(leaves?: TapLeaf[]): Taptree;
+export declare function checkTaprootInputForSigs(input: PsbtInput, action: string): boolean;
+export declare function getTapKeySigFromWitness(finalScriptWitness?: Buffer): Buffer | undefined;

package/build/psbt/bip371.js

@@ -0,0 +1,246 @@
+import { isTapleaf, isTaptree } from '../types.js';
+import { Transaction } from '../transaction.js';
+import { LEAF_VERSION_TAPSCRIPT, MAX_TAPTREE_DEPTH, rootHashFromPath, tapleafHash, tweakKey, } from '../payments/bip341.js';
+import { p2tr } from '../payments/p2tr.js';
+import { isP2TR, pubkeyPositionInScript, signatureBlocksAction, witnessStackToScriptWitness, } from './psbtutils.js';
+export const toXOnly = (pubKey) => {
+    const buffer = pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+};
+export function tapScriptFinalizer(inputIndex, input, tapLeafHashToFinalize) {
+    const tapLeaf = findTapLeafToFinalize(input, inputIndex, tapLeafHashToFinalize);
+    try {
+        const sigs = sortSignatures(input, tapLeaf);
+        const witness = sigs.concat(tapLeaf.script).concat(tapLeaf.controlBlock);
+        return { finalScriptWitness: witnessStackToScriptWitness(witness) };
+    }
+    catch (err) {
+        throw new Error(`Can not finalize taproot input #${inputIndex}: ${err}`);
+    }
+}
+export function serializeTaprootSignature(sig, sighashType) {
+    const sighashTypeByte = sighashType ? Buffer.from([sighashType]) : Buffer.from([]);
+    return Buffer.concat([sig, sighashTypeByte]);
+}
+export function isTaprootInput(input) {
+    return (input &&
+        !!(input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo && isP2TR(input.witnessUtxo.script))));
+}
+export function isTaprootOutput(output, script) {
+    return (output &&
+        !!(output.tapInternalKey ||
+            output.tapTree ||
+            (output.tapBip32Derivation && output.tapBip32Derivation.length) ||
+            (script && isP2TR(script))));
+}
+export function checkTaprootInputFields(inputData, newInputData, action) {
+    checkMixedTaprootAndNonTaprootInputFields(inputData, newInputData, action);
+    checkIfTapLeafInTree(inputData, newInputData, action);
+}
+export function checkTaprootOutputFields(outputData, newOutputData, action) {
+    checkMixedTaprootAndNonTaprootOutputFields(outputData, newOutputData, action);
+    checkTaprootScriptPubkey(outputData, newOutputData);
+}
+function checkTaprootScriptPubkey(outputData, newOutputData) {
+    if (!newOutputData.tapTree && !newOutputData.tapInternalKey)
+        return;
+    const tapInternalKey = newOutputData.tapInternalKey || outputData.tapInternalKey;
+    const tapTree = newOutputData.tapTree || outputData.tapTree;
+    if (tapInternalKey) {
+        const { script: scriptPubkey } = outputData;
+        const script = getTaprootScripPubkey(tapInternalKey, tapTree);
+        if (scriptPubkey && !scriptPubkey.equals(script))
+            throw new Error('Error adding output. Script or address missmatch.');
+    }
+}
+function getTaprootScripPubkey(tapInternalKey, tapTree) {
+    const scriptTree = tapTree && tapTreeFromList(tapTree.leaves);
+    const { output } = p2tr({
+        internalPubkey: tapInternalKey,
+        scriptTree,
+    });
+    return output;
+}
+export function tweakInternalPubKey(inputIndex, input) {
+    const tapInternalKey = input.tapInternalKey;
+    const outputKey = tapInternalKey && tweakKey(tapInternalKey, input.tapMerkleRoot);
+    if (!outputKey)
+        throw new Error(`Cannot tweak tap internal key for input #${inputIndex}. Public key: ${tapInternalKey && tapInternalKey.toString('hex')}`);
+    return outputKey.x;
+}
+export function tapTreeToList(tree) {
+    if (!isTaptree(tree))
+        throw new Error('Cannot convert taptree to tapleaf list. Expecting a tapree structure.');
+    return _tapTreeToList(tree);
+}
+export function tapTreeFromList(leaves = []) {
+    if (leaves.length === 1 && leaves[0].depth === 0)
+        return {
+            output: leaves[0].script,
+            version: leaves[0].leafVersion,
+        };
+    return insertLeavesInTree(leaves);
+}
+export function checkTaprootInputForSigs(input, action) {
+    const sigs = extractTaprootSigs(input);
+    return sigs.some((sig) => signatureBlocksAction(sig, decodeSchnorrSignature, action));
+}
+function decodeSchnorrSignature(signature) {
+    return {
+        signature: signature.slice(0, 64),
+        hashType: signature.slice(64)[0] || Transaction.SIGHASH_DEFAULT,
+    };
+}
+function extractTaprootSigs(input) {
+    const sigs = [];
+    if (input.tapKeySig)
+        sigs.push(input.tapKeySig);
+    if (input.tapScriptSig)
+        sigs.push(...input.tapScriptSig.map((s) => s.signature));
+    if (!sigs.length) {
+        const finalTapKeySig = getTapKeySigFromWitness(input.finalScriptWitness);
+        if (finalTapKeySig)
+            sigs.push(finalTapKeySig);
+    }
+    return sigs;
+}
+export function getTapKeySigFromWitness(finalScriptWitness) {
+    if (!finalScriptWitness)
+        return;
+    const witness = finalScriptWitness.slice(2);
+    if (witness.length === 64 || witness.length === 65)
+        return witness;
+}
+function _tapTreeToList(tree, leaves = [], depth = 0) {
+    if (depth > MAX_TAPTREE_DEPTH)
+        throw new Error('Max taptree depth exceeded.');
+    if (!tree)
+        return [];
+    if (isTapleaf(tree)) {
+        leaves.push({
+            depth,
+            leafVersion: tree.version || LEAF_VERSION_TAPSCRIPT,
+            script: tree.output,
+        });
+        return leaves;
+    }
+    if (tree[0])
+        _tapTreeToList(tree[0], leaves, depth + 1);
+    if (tree[1])
+        _tapTreeToList(tree[1], leaves, depth + 1);
+    return leaves;
+}
+function insertLeavesInTree(leaves) {
+    let tree;
+    for (const leaf of leaves) {
+        tree = insertLeafInTree(leaf, tree);
+        if (!tree)
+            throw new Error(`No room left to insert tapleaf in tree`);
+    }
+    return tree;
+}
+function insertLeafInTree(leaf, tree, depth = 0) {
+    if (depth > MAX_TAPTREE_DEPTH)
+        throw new Error('Max taptree depth exceeded.');
+    if (leaf.depth === depth) {
+        if (!tree)
+            return {
+                output: leaf.script,
+                version: leaf.leafVersion,
+            };
+        return;
+    }
+    if (isTapleaf(tree))
+        return;
+    const leftSide = insertLeafInTree(leaf, tree && tree[0], depth + 1);
+    if (leftSide)
+        return [leftSide, tree && tree[1]];
+    const rightSide = insertLeafInTree(leaf, tree && tree[1], depth + 1);
+    if (rightSide)
+        return [tree && tree[0], rightSide];
+}
+function checkMixedTaprootAndNonTaprootInputFields(inputData, newInputData, action) {
+    const isBadTaprootUpdate = isTaprootInput(inputData) && hasNonTaprootFields(newInputData);
+    const isBadNonTaprootUpdate = hasNonTaprootFields(inputData) && isTaprootInput(newInputData);
+    const hasMixedFields = inputData === newInputData &&
+        isTaprootInput(newInputData) &&
+        hasNonTaprootFields(newInputData);
+    if (isBadTaprootUpdate || isBadNonTaprootUpdate || hasMixedFields)
+        throw new Error(`Invalid arguments for Psbt.${action}. ` +
+            `Cannot use both taproot and non-taproot fields.`);
+}
+function checkMixedTaprootAndNonTaprootOutputFields(inputData, newInputData, action) {
+    const isBadTaprootUpdate = isTaprootOutput(inputData) && hasNonTaprootFields(newInputData);
+    const isBadNonTaprootUpdate = hasNonTaprootFields(inputData) && isTaprootOutput(newInputData);
+    const hasMixedFields = inputData === newInputData &&
+        isTaprootOutput(newInputData) &&
+        hasNonTaprootFields(newInputData);
+    if (isBadTaprootUpdate || isBadNonTaprootUpdate || hasMixedFields)
+        throw new Error(`Invalid arguments for Psbt.${action}. ` +
+            `Cannot use both taproot and non-taproot fields.`);
+}
+function checkIfTapLeafInTree(inputData, newInputData, action) {
+    if (newInputData.tapMerkleRoot) {
+        const newLeafsInTree = (newInputData.tapLeafScript || []).every((l) => isTapLeafInTree(l, newInputData.tapMerkleRoot));
+        const oldLeafsInTree = (inputData.tapLeafScript || []).every((l) => isTapLeafInTree(l, newInputData.tapMerkleRoot));
+        if (!newLeafsInTree || !oldLeafsInTree)
+            throw new Error(`Invalid arguments for Psbt.${action}. Tapleaf not part of taptree.`);
+    }
+    else if (inputData.tapMerkleRoot) {
+        const newLeafsInTree = (newInputData.tapLeafScript || []).every((l) => isTapLeafInTree(l, inputData.tapMerkleRoot));
+        if (!newLeafsInTree)
+            throw new Error(`Invalid arguments for Psbt.${action}. Tapleaf not part of taptree.`);
+    }
+}
+function isTapLeafInTree(tapLeaf, merkleRoot) {
+    if (!merkleRoot)
+        return true;
+    const leafHash = tapleafHash({
+        output: tapLeaf.script,
+        version: tapLeaf.leafVersion,
+    });
+    const rootHash = rootHashFromPath(tapLeaf.controlBlock, leafHash);
+    return rootHash.equals(merkleRoot);
+}
+function sortSignatures(input, tapLeaf) {
+    const leafHash = tapleafHash({
+        output: tapLeaf.script,
+        version: tapLeaf.leafVersion,
+    });
+    return (input.tapScriptSig || [])
+        .filter((tss) => tss.leafHash.equals(leafHash))
+        .map((tss) => addPubkeyPositionInScript(tapLeaf.script, tss))
+        .sort((t1, t2) => t2.positionInScript - t1.positionInScript)
+        .map((t) => t.signature);
+}
+function addPubkeyPositionInScript(script, tss) {
+    return Object.assign({
+        positionInScript: pubkeyPositionInScript(tss.pubkey, script),
+    }, tss);
+}
+function findTapLeafToFinalize(input, inputIndex, leafHashToFinalize) {
+    if (!input.tapScriptSig || !input.tapScriptSig.length)
+        throw new Error(`Can not finalize taproot input #${inputIndex}. No tapleaf script signature provided.`);
+    const tapLeaf = (input.tapLeafScript || [])
+        .sort((a, b) => a.controlBlock.length - b.controlBlock.length)
+        .find((leaf) => canFinalizeLeaf(leaf, input.tapScriptSig, leafHashToFinalize));
+    if (!tapLeaf)
+        throw new Error(`Can not finalize taproot input #${inputIndex}. Signature for tapleaf script not found.`);
+    return tapLeaf;
+}
+function canFinalizeLeaf(leaf, tapScriptSig, hash) {
+    const leafHash = tapleafHash({
+        output: leaf.script,
+        version: leaf.leafVersion,
+    });
+    const whiteListedHash = !hash || hash.equals(leafHash);
+    return (whiteListedHash && tapScriptSig.find((tss) => tss.leafHash.equals(leafHash)) !== undefined);
+}
+function hasNonTaprootFields(io) {
+    return (io &&
+        !!(io.redeemScript || io.witnessScript || (io.bip32Derivation && io.bip32Derivation.length)));
+}

package/build/psbt/psbtutils.d.ts

@@ -0,0 +1,26 @@
+import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces.js';
+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;
+export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+export interface UncompressedPublicKey {
+    hybrid: Buffer;
+    uncompressed: Buffer;
+}
+export declare function decompressPublicKey(realPubKey: Uint8Array | Buffer): UncompressedPublicKey;
+export declare function bigIntTo32Bytes(num: bigint): Buffer;
+export declare function pubkeysMatch(a: Buffer, b: Buffer): boolean;
+export declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;
+export declare function checkInputForSig(input: PsbtInput, action: string): boolean;
+type SignatureDecodeFunc = (buffer: Buffer) => {
+    signature: Buffer;
+    hashType: number;
+};
+export declare function signatureBlocksAction(signature: Buffer, signatureDecodeFn: SignatureDecodeFunc, action: string): boolean;
+export declare function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[];
+export {};

package/build/psbt/psbtutils.js

@@ -0,0 +1,170 @@
+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 pubkeyHash = hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+    const uncompressed = decompressPublicKey(pubkey);
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null)
+        throw new Error('Unknown script error');
+    return decompiled.findIndex((element) => {
+        if (typeof element === 'number')
+            return false;
+        if (pubkeysMatch(element, pubkey))
+            return true;
+        if (pubkeysMatch(element, pubkeyXOnly))
+            return true;
+        if (pubkeysMatch(element, uncompressed.uncompressed))
+            return true;
+        if (pubkeysMatch(element, uncompressed.hybrid))
+            return true;
+        return element.equals(pubkeyHash);
+    });
+}
+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 }));
+}