@btc-vision/transaction 1.1.17 → 1.2.1

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

@@ -1,8 +1,5 @@
 // Helper functions
-import { crypto as bitCrypto, PsbtInput } from '@btc-vision/bitcoin';
-import { isP2TR } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import * as bscript from '@btc-vision/bitcoin/src/script.js';
+import { isP2TR, PsbtInput, pubkeyPositionInScript } from '@btc-vision/bitcoin';
 
 export function isTaprootInput(input: PsbtInput): boolean {
     return (
@@ -58,21 +55,12 @@ export function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boo
     return false;
 }
 
-export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
-    const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-
-    const decompiled = bscript.decompile(script);
-    if (decompiled === null) throw new Error('Unknown script error');
-
-    const a = decompiled.findIndex((element) => {
-        if (typeof element === 'number') return false;
-        return element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly);
-    });
-
-    return a;
-}
-
+/**
+ * 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(Buffer.copyBytesFrom(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();

package/src/transaction/TransactionFactory.ts

@@ -1,5 +1,4 @@
-import { Transaction } from '@btc-vision/bitcoin';
-import { Output } from '@btc-vision/bitcoin/src/transaction.js';
+import { Transaction, TxOutput } from '@btc-vision/bitcoin';
 import { currentConsensus } from '../consensus/ConsensusConfig.js';
 import { UTXO } from '../utxo/interfaces/IUTXO.js';
 import {
@@ -230,7 +229,7 @@ export class TransactionFactory {
             throw new Error('Could not sign funding transaction.');
         }
 
-        const out: Output = signedTransaction.outs[0];
+        const out: TxOutput = signedTransaction.outs[0];
         const newUtxo: UTXO = {
             transactionId: signedTransaction.getId(),
             outputIndex: 0, // always 0
@@ -254,7 +253,7 @@ export class TransactionFactory {
         // We have to regenerate using the new utxo
         const outTx: Transaction = await finalTransaction.signTransaction();
 
-        const out2: Output = signedTransaction.outs[1];
+        const out2: TxOutput = signedTransaction.outs[1];
         const refundUTXO: UTXO = {
             transactionId: signedTransaction.getId(),
             outputIndex: 1, // always 1
@@ -364,7 +363,7 @@ export class TransactionFactory {
     private getUTXOAsTransaction(tx: Transaction, to: string, index: number): UTXO[] {
         if (!tx.outs[index]) return [];
 
-        const out: Output = tx.outs[index];
+        const out: TxOutput = tx.outs[index];
         const newUtxo: UTXO = {
             transactionId: tx.getId(),
             outputIndex: index,

package/src/transaction/browser/extensions/UnisatSigner.ts

@@ -5,13 +5,13 @@ import {
     Psbt,
     script as bitScript,
     TapScriptSig,
+    toXOnly,
 } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 
 declare global {

package/src/transaction/browser/extensions/XverseSigner.ts

@@ -1,5 +1,4 @@
-import { Network, networks, Psbt, TapScriptSig } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { Network, networks, Psbt, TapScriptSig, toXOnly } from '@btc-vision/bitcoin';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -1,14 +1,21 @@
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import {
+    crypto as bitCrypto,
+    Payment,
+    Psbt,
+    PsbtInput,
+    Signer,
+    Stack,
+    Taptree,
+    toXOnly,
+} from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { crypto as bitCrypto, Payment, Psbt, PsbtInput, Signer, Stack } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { CustomGenerator } from '../../generators/builders/CustomGenerator.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressGenerator } from '../../generators/AddressGenerator.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { ECPairInterface } from 'ecpair';
 
 export interface ICustomTransactionParameters extends SharedInteractionParameters {

package/src/transaction/builders/DeploymentTransaction.ts

@@ -1,11 +1,17 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
-import { crypto as bitCrypto, Payment, Psbt, PsbtInput, Signer } from '@btc-vision/bitcoin';
+import {
+    crypto as bitCrypto,
+    Payment,
+    Psbt,
+    PsbtInput,
+    Signer,
+    Taptree,
+    toXOnly,
+} from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { Compressor } from '../../bytecode/Compressor.js';
@@ -14,6 +20,8 @@ import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
+const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
@@ -90,6 +98,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
     private readonly randomBytes: Buffer;
 
     public constructor(parameters: IDeploymentParameters) {
+        // TODO: Add legacy deployment, this is only p2tr.
         super(parameters);
 
         this.bytecode = Compressor.compress(parameters.bytecode);
@@ -317,6 +326,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             throw new Error('Bytecode is required');
         }
 
+        // Concatenate deployer pubkey, salt, and sha256(bytecode)
         const deployerPubKey: Buffer = this.internalPubKeyToXOnly();
         const salt: Buffer = bitCrypto.hash256(this.randomBytes);
         const sha256OfBytecode: Buffer = bitCrypto.hash256(this.bytecode);

package/src/transaction/builders/FundingTransaction.ts

@@ -29,14 +29,14 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         if (this.splitInputsInto > 1) {
             this.splitInputs(this.amount);
         } else if (this.isPubKeyDestination) {
-            const p2pkScript = script.compile([
+            const pubKeyScript = script.compile([
                 Buffer.from(this.to.replace('0x', ''), 'hex'),
                 opcodes.OP_CHECKSIG,
             ]);
 
             this.addOutput({
                 value: Number(this.amount),
-                script: p2pkScript,
+                script: pubKeyScript,
             });
         } else {
             this.addOutput({

package/src/transaction/builders/InteractionTransaction.ts

@@ -1,4 +1,4 @@
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Taptree } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';

package/src/transaction/builders/MultiSignTransaction.ts

@@ -9,14 +9,14 @@ import {
     script,
     Signer,
     TapScriptSig,
+    Taptree,
+    toXOnly,
 } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';
 import { MultiSignGenerator } from '../../generators/builders/MultiSignGenerator.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { ECPairInterface } from 'ecpair';
 

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -1,5 +1,4 @@
-import { address, Payment, Psbt, PsbtInput, Signer } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { address, Payment, Psbt, PsbtInput, Signer, Taptree, toXOnly } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
@@ -8,7 +7,6 @@ import { SharedInteractionParameters } from '../interfaces/ITransactionParameter
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 /**

package/src/transaction/builders/TransactionBuilder.ts

@@ -8,8 +8,8 @@ import {
     script,
     Signer,
     Transaction,
+    varuint,
 } from '@btc-vision/bitcoin';
-import { varuint } from '@btc-vision/bitcoin/src/bufferutils.js';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { UpdateInput } from '../interfaces/Tap.js';
 import { TransactionType } from '../enums/TransactionType.js';
@@ -473,6 +473,16 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                     address: this.from,
                     tapInternalKey: this.internalPubKeyToXOnly(),
                 });
+            } else if (AddressVerificator.isValidPublicKey(this.from, this.network)) {
+                const pubKeyScript = script.compile([
+                    Buffer.from(this.from.replace('0x', ''), 'hex'),
+                    opcodes.OP_CHECKSIG,
+                ]);
+
+                await this.setFeeOutput({
+                    value: Number(sendBackAmount),
+                    script: pubKeyScript,
+                });
             } else {
                 await this.setFeeOutput({
                     value: Number(sendBackAmount),

package/src/transaction/shared/TweakedTransaction.ts

@@ -3,6 +3,13 @@ import {
     address as bitAddress,
     crypto as bitCrypto,
     getFinalScripts,
+    isP2MS,
+    isP2PK,
+    isP2PKH,
+    isP2SHScript,
+    isP2TR,
+    isP2WPKH,
+    isP2WSHScript,
     Network,
     opcodes,
     Payment,
@@ -12,31 +19,22 @@ import {
     PsbtInputExtended,
     script,
     Signer,
+    toXOnly,
     Transaction,
+    varuint,
 } from '@btc-vision/bitcoin';
 
 import { TweakedSigner, TweakSettings } from '../../signer/TweakedSigner.js';
 import { ECPairInterface } from 'ecpair';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
-import { varuint } from '@btc-vision/bitcoin/src/bufferutils.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import {
     canSignNonTaprootInput,
     isTaprootInput,
     pubkeyInScript,
 } from '../../signer/SignerUtils.js';
-import {
-    isP2MS,
-    isP2PK,
-    isP2PKH,
-    isP2SHScript,
-    isP2TR,
-    isP2WPKH,
-    isP2WSHScript,
-} from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
 
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
@@ -803,88 +801,6 @@ export abstract class TweakedTransaction extends Logger {
         return input;
     }
 
-    /*protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended {
-        const input: PsbtInputExtended = {
-            hash: utxo.transactionId,
-            index: utxo.outputIndex,
-            sequence: this.sequence,
-            witnessUtxo: {
-                value: Number(utxo.value),
-                script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
-            },
-        };
-
-        if (utxo.scriptPubKey.address) {
-            // auto detect for potential p2sh utxos
-            try {
-                const addressType: AddressTypes | null = AddressVerificator.detectAddressType(
-                    utxo.scriptPubKey.address,
-                    this.network,
-                );
-
-                if (addressType === AddressTypes.P2SH_OR_P2SH_P2WPKH) {
-                    // We can automatically reconstruct the redeem script.
-                    const redeemScript = this.generateP2SHRedeemScriptLegacy(
-                        utxo.scriptPubKey.address,
-                    );
-
-                    if (!redeemScript) {
-                        throw new Error('Failed to generate redeem script');
-                    }
-
-                    input.redeemScript = redeemScript.outputScript;
-                    input.witnessScript = redeemScript.redeemScript;
-                }
-            } catch (e) {
-                this.error(`Failed to detect address type for ${utxo.scriptPubKey.address} - ${e}`);
-            }
-        }
-
-        // LEGACY P2SH SUPPORT
-        if (utxo.nonWitnessUtxo) {
-            input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
-                ? utxo.nonWitnessUtxo
-                : Buffer.from(utxo.nonWitnessUtxo, 'hex');
-        }
-
-        // SEGWIT SUPPORT
-        if (utxo.redeemScript) {
-            input.redeemScript = Buffer.isBuffer(utxo.redeemScript)
-                ? utxo.redeemScript
-                : Buffer.from(utxo.redeemScript, 'hex');
-
-            if (utxo.witnessScript) {
-                input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
-                    ? utxo.witnessScript
-                    : Buffer.from(utxo.witnessScript, 'hex');
-            }
-        }
-
-        // TAPROOT.
-        if (this.sighashTypes) {
-            const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
-            if (inputSign) input.sighashType = inputSign;
-        }
-
-        if (i === 0 && this.nonWitnessUtxo) {
-            input.nonWitnessUtxo = this.nonWitnessUtxo;
-        }
-
-        // Automatically detect P2TR inputs.
-        if (
-            utxo.scriptPubKey.address &&
-            AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)
-        ) {
-            this.tweakSigner();
-
-            input.tapInternalKey = this.internalPubKeyToXOnly();
-        }
-
-        console.log(input);
-
-        return input;
-    }*/
-
     protected customFinalizerP2SH = (
         inputIndex: number,
         input: PsbtInput,

package/src/utils/BufferHelper.ts

@@ -21,7 +21,7 @@ export class BufferHelper {
     }
 
     public static uint8ArrayToHex(input: Uint8Array): string {
-        return Buffer.from(input, 0, input.byteLength).toString('hex');
+        return Buffer.from(input.buffer, 0, input.byteLength).toString('hex');
     }
 
     public static hexToUint8Array(input: string): Uint8Array {

package/src/verification/TapscriptVerificator.ts

@@ -1,6 +1,12 @@
-import { crypto as bitCrypto, Network, networks, Payment, payments } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import {
+    crypto as bitCrypto,
+    Network,
+    networks,
+    Payment,
+    payments,
+    Taptree,
+    toXOnly,
+} from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
 import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
 import { Address } from '../keypair/Address.js';