@btc-vision/transaction 1.1.16 → 1.2.0

package/src/keypair/Address.ts

@@ -1,9 +1,9 @@
-import { Network } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { decompressPublicKey, Network, toXOnly, UncompressedPublicKey } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
 import { EcKeyPair } from './EcKeyPair.js';
+import { ContractAddress } from '../transaction/ContractAddress.js';
 
 const hexPattern = /^[0-9a-fA-F]+$/;
 const isHexadecimal = (input: string): boolean => {
@@ -19,6 +19,8 @@ export class Address extends Uint8Array {
     #network: Network | undefined;
     #originalPublicKey: Uint8Array | undefined;
     #keyPair: ECPairInterface | undefined;
+    #uncompressed: UncompressedPublicKey | undefined;
+    #tweakedUncompressed: Buffer | undefined;
 
     public constructor(bytes?: ArrayLike<number>) {
         super(ADDRESS_BYTE_LENGTH);
@@ -88,6 +90,19 @@ export class Address extends Uint8Array {
         return new Address(bytes);
     }
 
+    public static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer {
+        const buffer = Uint8Array.from(publicKey);
+
+        const x = buffer.slice(1, 33);
+        const y = buffer.slice(33);
+
+        const compressed = Buffer.alloc(33);
+        compressed[0] = 0x02 + (y[y.length - 1] & 0x01);
+        compressed.set(x, 1);
+
+        return compressed;
+    }
+
     /**
      * Converts the address to a hex string
      * @returns {string} The hex string
@@ -104,6 +119,46 @@ export class Address extends Uint8Array {
         return Buffer.from(this);
     }
 
+    public toUncompressedHex(): string {
+        if (!this.#uncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return '0x' + this.#uncompressed.uncompressed.toString('hex');
+    }
+
+    public toUncompressedBuffer(): Buffer {
+        if (!this.#uncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return this.#uncompressed.uncompressed;
+    }
+
+    public toHybridPublicKeyHex(): string {
+        if (!this.#uncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return '0x' + this.#uncompressed.hybrid.toString('hex');
+    }
+
+    public toHybridPublicKeyBuffer(): Buffer {
+        if (!this.#uncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return this.#uncompressed.hybrid;
+    }
+
+    public originalPublicKeyBuffer(): Buffer {
+        if (!this.#originalPublicKey) {
+            throw new Error('Public key not set');
+        }
+
+        return Buffer.from(this.#originalPublicKey);
+    }
+
     public equals(a: Address): boolean {
         const b: Address = this as Address;
 
@@ -178,16 +233,11 @@ export class Address extends Uint8Array {
             const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
             buf.set(publicKey);
 
+            this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
+
             super.set(publicKey);
         } else {
-            this.#originalPublicKey = Uint8Array.from(publicKey);
-            this.#keyPair = EcKeyPair.fromPublicKey(this.#originalPublicKey);
-
-            const tweakedBytes = toXOnly(
-                EcKeyPair.tweakPublicKey(Buffer.from(this.#originalPublicKey)),
-            );
-
-            super.set(tweakedBytes);
+            this.autoFormat(publicKey);
         }
     }
 
@@ -200,6 +250,13 @@ export class Address extends Uint8Array {
         return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
     }
 
+    /**
+     * Get the public key as address
+     */
+    public p2pk(): string {
+        return this.toHex();
+    }
+
     /**
      * Get the address in p2wpkh format
      * @param {Network} network The network
@@ -258,4 +315,43 @@ export class Address extends Uint8Array {
 
         throw new Error('Public key not set');
     }
+
+    public toTweakedHybridPublicKeyHex(): string {
+        if (!this.#tweakedUncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return '0x' + this.#tweakedUncompressed.toString('hex');
+    }
+
+    public toTweakedHybridPublicKeyBuffer(): Buffer {
+        if (!this.#tweakedUncompressed) {
+            throw new Error('Public key not set');
+        }
+
+        return this.#tweakedUncompressed;
+    }
+
+    private autoFormat(publicKey: ArrayLike<number>): void {
+        const firstByte = publicKey[0];
+
+        if (firstByte === 0x03 || firstByte === 0x02) {
+            // do nothing
+        } else if (firstByte === 0x04 || firstByte === 0x06 || firstByte === 0x07) {
+            // uncompressed
+            publicKey = Address.uncompressedToCompressed(publicKey);
+        }
+
+        this.#originalPublicKey = Uint8Array.from(publicKey);
+        this.#keyPair = EcKeyPair.fromPublicKey(this.#originalPublicKey);
+        this.#uncompressed = decompressPublicKey(this.#originalPublicKey);
+
+        const tweakedBytes: Buffer = toXOnly(
+            EcKeyPair.tweakPublicKey(Buffer.from(this.#originalPublicKey)),
+        );
+
+        this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(tweakedBytes);
+
+        super.set(tweakedBytes);
+    }
 }

package/src/keypair/AddressVerificator.ts

@@ -109,14 +109,18 @@ export class AddressVerificator {
                 return true;
             }
 
+            const pubKeyBuffer = Buffer.from(input, 'hex');
+            if ((input.length === 130 && pubKeyBuffer[0] === 0x06) || pubKeyBuffer[0] === 0x07) {
+                return true;
+            }
+
             if (input.length === 66 || input.length === 130) {
                 // Check if the input can be parsed as a valid public key
-                const pubKeyBuffer = Buffer.from(input, 'hex');
                 EcKeyPair.fromPublicKey(pubKeyBuffer, network);
 
                 return true;
             }
-        } catch {
+        } catch (e) {
             return false;
         }
 

package/src/keypair/EcKeyPair.ts

@@ -1,11 +1,18 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
-import { address, initEccLib, Network, networks, payments, Signer } from '@btc-vision/bitcoin';
+import {
+    address,
+    initEccLib,
+    Network,
+    networks,
+    payments,
+    Signer,
+    taggedHash,
+    toXOnly,
+} from '@btc-vision/bitcoin';
 import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
 import { CURVE, ProjectivePoint as Point } from '@noble/secp256k1';
-import { taggedHash } from '@btc-vision/bitcoin/src/crypto.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 
 initEccLib(ecc);
 
@@ -154,8 +161,10 @@ export class EcKeyPair {
         }
 
         // Convert the tweaked public key hex string to a Buffer
-        let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
-        if (tweakedPubKeyBuffer.length !== 32) tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+        let tweakedPubKeyBuffer: Buffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        if (tweakedPubKeyBuffer.length !== 32) {
+            tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+        }
 
         return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
     }

package/src/keypair/MessageSigner.ts

@@ -1,9 +1,8 @@
 import { ECPairInterface } from 'ecpair';
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { crypto, Network } from '@btc-vision/bitcoin';
+import { crypto, Network, toXOnly } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../signer/TweakedSigner.js';
 import { EcKeyPair } from './EcKeyPair.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 
 export interface SignedMessage {
     readonly signature: Uint8Array;

package/src/keypair/Secp256k1PointDeriver.ts

@@ -0,0 +1,170 @@
+const P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+
+export class Secp256k1PointDeriver {
+    /**
+     * The maximum increments to try before giving up on deriving a valid x.
+     */
+    private maxTries: number;
+
+    constructor(maxTries = 10000) {
+        this.maxTries = maxTries;
+    }
+
+    /**
+     * Main entry point.
+     * Given a 32-byte input, ensures we obtain a "real" x on secp256k1.
+     * - If the given x is valid, we use it.
+     * - Otherwise, we increment x (mod p) until we find one whose (x^3 + 7) is a quadratic residue.
+     * Then we return { x, y1, y2 } for that valid point.
+     *
+     * @param xBytes A 32-byte Uint8Array for the candidate x
+     * @param failOnInvalidX (optional) whether to throw if the given x is not a valid curve point, defaults to true
+     * @param maxTries (optional) number of increments to attempt, defaults to this.maxTries
+     * @returns An object { x: bigint; y1: bigint; y2: bigint } describing a valid curve point
+     * @throws If no valid x found within maxTries
+     */
+    public findOrDeriveValidPoint(
+        xBytes: Uint8Array,
+        failOnInvalidX: boolean = true,
+        maxTries: number = this.maxTries,
+    ): { x: bigint; y1: bigint; y2: bigint } {
+        if (xBytes.length !== 32) {
+            throw new Error('xBytes must be exactly 32 bytes.');
+        }
+
+        // Convert input to a BigInt in [0, p-1]
+        let xCandidate = this.bytesToBigInt(xBytes) % P;
+
+        // 2. Loop up to maxTries to find a valid x
+        let sqrtVal = this.isValidX(xCandidate);
+        if (failOnInvalidX && sqrtVal === null) {
+            throw new Error(`The given x is not a valid curve point.`);
+        }
+
+        let tries = 0;
+        while (sqrtVal === null) {
+            xCandidate = (xCandidate + 1n) % P;
+            sqrtVal = this.isValidX(xCandidate);
+
+            tries++;
+            if (tries > maxTries) {
+                throw new Error(`Could not find a valid X point within ${maxTries} increments.`);
+            }
+        }
+
+        // Now, sqrtVal is a valid 'r' for alpha = x^3 + 7
+        // The two roots for y are: r and p-r
+        const y1 = sqrtVal;
+        const y2 = (P - y1) % P;
+
+        return { x: xCandidate, y1, y2 };
+    }
+
+    /**
+     * Given two candidate y values, returns the one with the smaller y-coordinate.
+     * @param {bigint} y
+     * @param {bigint} y2
+     */
+    public getCanonicalY(y: bigint, y2: bigint): bigint {
+        return y < y2 ? y : y2;
+    }
+
+    /**
+     * Creates a 65-byte "hybrid public key" from the specified x and y.
+     * - First byte:
+     *   - 0x06 if y is even
+     *   - 0x07 if y is odd
+     * - Next 32 bytes: x
+     * - Last 32 bytes: y
+     *
+     * @param x X-coordinate as a bigint
+     * @param y Y-coordinate as a bigint
+     * @returns A Uint8Array of length 65
+     */
+    public getHybridPublicKey(x: bigint, y: bigint): Uint8Array {
+        // Determine prefix based on parity of y
+        const prefix = y % 2n === 0n ? 0x06 : 0x07;
+
+        // Convert x and y to 32-byte big-endian arrays
+        const xBytes = this.bigIntTo32Bytes(x);
+        const yBytes = this.bigIntTo32Bytes(y);
+
+        // Allocate 65 bytes: 1 for prefix + 32 for x + 32 for y
+        const hybrid = new Uint8Array(65);
+        hybrid[0] = prefix;
+        hybrid.set(xBytes, 1);
+        hybrid.set(yBytes, 33);
+
+        return hybrid;
+    }
+
+    /**
+     * Checks if (x^3 + 7) is a quadratic residue mod p.
+     * Returns the square root if it is, or null if not.
+     */
+    private isValidX(x: bigint): bigint | null {
+        // alpha = (x^3 + 7) mod p
+        const alpha = (this.modPow(x, 3n, P) + 7n) % P;
+        return this.sqrtModP(alpha, P);
+    }
+
+    /**
+     * Computes base^exp (mod m) using exponentiation by squaring.
+     */
+    private modPow(base: bigint, exp: bigint, m: bigint): bigint {
+        let result = 1n;
+        let cur = base % m;
+        let e = exp;
+
+        while (e > 0) {
+            if ((e & 1n) === 1n) {
+                result = (result * cur) % m;
+            }
+            cur = (cur * cur) % m;
+            e >>= 1n;
+        }
+        return result;
+    }
+
+    /**
+     * sqrtModP(a, p):
+     *   Attempts to compute the square root of `a` modulo prime `p`.
+     *   Returns the root if it exists, or null if `a` is not a quadratic residue.
+     *
+     * Since p ≡ 3 (mod 4), we can do:
+     *   sqrt(a) = a^((p+1)/4) mod p
+     */
+    private sqrtModP(a: bigint, prime: bigint): bigint | null {
+        // Candidate root
+        const root = this.modPow(a, (prime + 1n) >> 2n, prime);
+
+        // Check if it's truly a root
+        if ((root * root) % prime !== a % prime) {
+            return null;
+        }
+        return root;
+    }
+
+    /**
+     * Convert a 32-byte Uint8Array (big-endian) to a BigInt.
+     */
+    private bytesToBigInt(bytes: Uint8Array): bigint {
+        let b = 0n;
+        for (const byte of bytes) {
+            b = (b << 8n) | BigInt(byte);
+        }
+        return b;
+    }
+
+    /**
+     * Convert a BigInt to a 32-byte array (big-endian).
+     */
+    private bigIntTo32Bytes(value: bigint): Uint8Array {
+        const bytes = new Uint8Array(32);
+        for (let i = 31; i >= 0; i--) {
+            bytes[i] = Number(value & 0xffn);
+            value >>= 8n;
+        }
+        return bytes;
+    }
+}

package/src/keypair/Wallet.ts

@@ -1,8 +1,7 @@
 import { IWallet } from './interfaces/IWallet.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from './EcKeyPair.js';
-import { Network, networks } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 import { Address } from './Address.js';
 
 /**

package/src/opnet.ts

@@ -91,3 +91,5 @@ export * from './transaction/browser/types/Xverse.js';
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 
+export * from './transaction/ContractAddress.js';
+export * from './keypair/Secp256k1PointDeriver.js';

package/src/signer/SignerUtils.ts

@@ -0,0 +1,66 @@
+// Helper functions
+import { isP2TR, PsbtInput, pubkeyPositionInScript } from '@btc-vision/bitcoin';
+
+export function isTaprootInput(input: PsbtInput): boolean {
+    return (
+        input &&
+        !!(
+            input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo && isP2TR(input.witnessUtxo.script))
+        )
+    );
+}
+
+export function getInputRelevantScript(input: PsbtInput): Buffer | null {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+        // Parse the full transaction from nonWitnessUtxo
+        /*const tx = Transaction.fromBuffer(input.nonWitnessUtxo);
+        // Retrieve the output referenced by the input index
+        const out = tx.outs[input.index];
+        if (!out) {
+            throw new Error(`No output at index ${input.index} in nonWitnessUtxo`);
+        }
+        return out.script;*/
+    }
+    return null;
+}
+
+export function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean {
+    if (
+        (input.nonWitnessUtxo &&
+            !input.redeemScript &&
+            !input.witnessScript &&
+            !input.witnessUtxo) ||
+        input.redeemScript
+    ) {
+        return true;
+    }
+
+    const script = getInputRelevantScript(input);
+    if (script) {
+        return pubkeyInScript(publicKey, script);
+    }
+    return false;
+}
+
+/**
+ * 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 function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}

package/src/signer/TweakedSigner.ts

@@ -1,7 +1,5 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { initEccLib, Network, Signer } from '@btc-vision/bitcoin';
-import { tapTweakHash } from '@btc-vision/bitcoin/src/payments/bip341.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { initEccLib, Network, Signer, tapTweakHash, toXOnly } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../keypair/EcKeyPair.js';
 

package/src/transaction/ContractAddress.ts

@@ -0,0 +1,13 @@
+import { Secp256k1PointDeriver } from '../keypair/Secp256k1PointDeriver.js';
+
+class ContractAddressBase {
+    private readonly deriver: Secp256k1PointDeriver = new Secp256k1PointDeriver();
+
+    public generateHybridKeyFromHash(input: Buffer): Buffer {
+        const p = this.deriver.findOrDeriveValidPoint(input, false);
+        const y = this.deriver.getCanonicalY(p.y1, p.y2);
+        return Buffer.from(this.deriver.getHybridPublicKey(p.x, y));
+    }
+}
+
+export const ContractAddress = new ContractAddressBase();