@btc-vision/bitcoin 6.5.3 → 6.5.4

package/src/pubkey.ts

@@ -0,0 +1,99 @@
+/**
+ * Public key utilities for Bitcoin
+ * @packageDocumentation
+ */
+import { ProjectivePoint } from '@noble/secp256k1';
+
+/**
+ * Converts a public key to x-only format (32 bytes).
+ * @param pubKey - The public key buffer (33 or 65 bytes)
+ * @returns The x-only public key (32 bytes)
+ */
+export const toXOnly = (pubKey: Buffer | Uint8Array): Buffer => {
+    const buffer = pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
+    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+};
+
+export interface UncompressedPublicKey {
+    hybrid: Buffer;
+    uncompressed: Buffer;
+}
+
+/**
+ * Converts bigint to 32-byte Buffer.
+ */
+export function bigIntTo32Bytes(num: bigint): Buffer {
+    let hex = num.toString(16);
+    hex = hex.padStart(64, '0');
+    if (hex.length > 64) {
+        hex = hex.slice(-64);
+    }
+    return Buffer.from(hex, 'hex');
+}
+
+/**
+ * Converts an existing real Bitcoin public key (compressed or uncompressed)
+ * to its "hybrid" form (prefix 0x06/0x07), then derives a P2PKH address from it.
+ *
+ * @param realPubKey - 33-byte compressed (0x02/0x03) or 65-byte uncompressed (0x04) pubkey
+ * @returns Buffer | undefined
+ */
+export function decompressPublicKey(
+    realPubKey: Uint8Array | Buffer,
+): UncompressedPublicKey | undefined {
+    if (realPubKey.length === 32) {
+        return;
+    }
+
+    if (![33, 65].includes(realPubKey.length)) {
+        console.warn(
+            `Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`,
+        );
+        return;
+    }
+
+    let point: ProjectivePoint;
+    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,
+    };
+}
+
+/**
+ * Compare two potential pubkey Buffers, treating hybrid keys (0x06/0x07)
+ * as equivalent to uncompressed (0x04).
+ */
+export function pubkeysMatch(a: Buffer, b: Buffer): boolean {
+    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;
+}

package/src/script.ts

@@ -4,11 +4,11 @@
  */
 import * as bip66 from './bip66.js';
 import { Opcodes, opcodes, REVERSE_OPS } from './opcodes.js';
-import { Stack } from './payments/index.js';
 import * as pushdata from './push_data.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
 import * as types from './types.js';
+import type { Stack } from './types.js';
 
 const { typeforce } = types;
 
@@ -229,12 +229,7 @@ export function isCanonicalPubKey(buffer: Buffer): boolean {
     return types.isPoint(buffer);
 }
 
-export function isDefinedHashType(hashType: number): boolean {
-    const hashTypeMod = hashType & ~0x80;
-
-    // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
-    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
-}
+import { isDefinedHashType } from './script_signature.js';
 
 export function isCanonicalScriptSignature(buffer: Buffer): boolean {
     if (!Buffer.isBuffer(buffer)) return false;

package/src/script_signature.ts

@@ -1,11 +1,20 @@
 import * as bip66 from './bip66.js';
-import { isDefinedHashType } from './script.js';
 import * as types from './types.js';
 
 const { typeforce } = types;
 
 const ZERO = Buffer.alloc(1, 0);
 
+/**
+ * Checks if a hash type is defined (valid for Bitcoin signatures).
+ * @param hashType - The hash type to check.
+ * @returns True if the hash type is valid, false otherwise.
+ */
+export function isDefinedHashType(hashType: number): boolean {
+    const hashTypeMod = hashType & ~0x80;
+    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
+
 /**
  * Converts a buffer to a DER-encoded buffer.
  * @param x - The buffer to be converted.

package/src/types.ts

@@ -125,3 +125,8 @@ export const Function: TypeforceValidator = typeforce.Function;
 export const BufferN: (n: number) => TypeforceValidator = typeforce.BufferN;
 export const Null: TypeforceValidator = typeforce.Null;
 export const oneOf: (...types: unknown[]) => TypeforceValidator = typeforce.oneOf;
+
+// Stack types - used by script and payments
+export type StackElement = globalThis.Buffer | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;

package/test/address.spec.ts

@@ -2,6 +2,7 @@ import assert from 'assert';
 import { describe, it } from 'vitest';
 import * as ecc from 'tiny-secp256k1';
 import * as baddress from '../src/address.js';
+import { fromBech32 } from '../src/bech32utils.js';
 import * as bscript from '../src/script.js';
 import fixtures from './fixtures/address.json' with { type: 'json' };
 
@@ -57,7 +58,7 @@ describe('address', () => {
             if (!f.bech32) return;
 
             it('decodes ' + f.bech32, () => {
-                const actual = baddress.fromBech32(f.bech32);
+                const actual = fromBech32(f.bech32);
 
                 assert.strictEqual(actual.version, f.version);
                 // Support both bech32 and bech32Opnet prefixes
@@ -74,7 +75,7 @@ describe('address', () => {
         fixtures.invalid.bech32.forEach((f) => {
             it('decode fails for ' + f.address + '(' + f.exception + ')', () => {
                 assert.throws(() => {
-                    baddress.fromBech32(f.address);
+                    fromBech32(f.address);
                 }, new RegExp(f.exception));
             });
         });

package/test/integration/taproot.spec.ts

@@ -7,8 +7,9 @@ import { regtestUtils } from './_regtest.js';
 import * as bitcoin from '../../src/index.js';
 import type { PsbtInput, TapLeaf, TapLeafScript, Taptree } from '../../src/index.js';
 import { LEAF_VERSION_TAPSCRIPT } from '../../src/payments/bip341.js';
-import { tapTreeFromList, tapTreeToList, toXOnly } from '../../src/psbt/bip371.js';
+import { tapTreeFromList, tapTreeToList } from '../../src/psbt/bip371.js';
 import { witnessStackToScriptWitness } from '../../src/psbt/psbtutils.js';
+import { toXOnly } from '../../src/pubkey.js';
 
 import rng from 'randombytes';