@btc-vision/transaction 1.1.16 → 1.1.17

package/build/utils/BitcoinUtils.js

@@ -1,4 +1,4 @@
-import crypto, { createHash } from 'crypto';
+import { createHash } from 'crypto';
 export class BitcoinUtils {
     static btcToSatoshi(btc) {
         return BigInt(btc * 100000000);
@@ -15,13 +15,13 @@ export class BitcoinUtils {
             window.crypto.getRandomValues(array);
             return Buffer.from(array);
         }
-        else if (crypto && typeof crypto.getRandomValues === 'function') {
+        else if (globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function') {
             const array = new Uint8Array(length);
-            crypto.getRandomValues(array);
+            globalThis.crypto.getRandomValues(array);
             return Buffer.from(array);
         }
         else {
-            console.log(`No secure random number generator available. Please upgrade your environment.`, globalThis.window.crypto, crypto);
+            console.log(`No secure random number generator available. Please upgrade your environment.`, globalThis.window.crypto, globalThis.crypto);
             throw new Error('No secure random number generator available. Please upgrade your environment.');
         }
     }

package/build/utxo/OPNetLimitedProvider.js

@@ -58,6 +58,7 @@ export class OPNetLimitedProvider {
                 outputIndex: utxo.outputIndex,
                 value: utxoValue,
                 scriptPubKey: utxo.scriptPubKey,
+                nonWitnessUtxo: Buffer.from(utxo.raw, 'base64'),
             });
             if (currentAmount > amountRequested) {
                 break;

package/build/utxo/interfaces/IUTXO.d.ts

@@ -27,4 +27,5 @@ export interface RawUTXOResponse {
     readonly outputIndex: number;
     readonly value: string;
     readonly scriptPubKey: ScriptPubKey;
+    readonly raw: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.16",
+    "version": "1.1.17",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -63,9 +63,6 @@
         "browserBuild": "webpack --mode production",
         "docs": "typedoc --out docs --exclude 'src/tests/*.ts' --tsconfig tsconfig.json --readme README.md --name OPNet --plugin typedoc-material-theme --themeColor '#cb9820' --exclude src/tests/test.ts --exclude src/index.ts src"
     },
-    "peerDependencies": {
-        "@btc-vision/bitcoin": "^6.3.0"
-    },
     "devDependencies": {
         "@babel/core": "^7.26.0",
         "@babel/plugin-proposal-class-properties": "^7.18.6",
@@ -94,7 +91,7 @@
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bitcoin": "^6.3.0",
+        "@btc-vision/bitcoin": "^6.3.1",
         "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.14.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.16';
+export const version = '1.1.17';

package/src/keypair/Address.ts

@@ -104,6 +104,14 @@ export class Address extends Uint8Array {
         return Buffer.from(this);
     }
 
+    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;
 
@@ -200,6 +208,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

package/src/signer/SignerUtils.ts

@@ -0,0 +1,78 @@
+// 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';
+
+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;
+}
+
+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;
+}
+
+export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}

package/src/transaction/TransactionFactory.ts

@@ -51,15 +51,6 @@ export interface BitcoinTransferResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-/*export interface UnwrapResult {
-    readonly fundingTransaction: string;
-    readonly psbt: string;
-
-    readonly feeRefundOrLoss: bigint;
-
-    readonly utxos: UTXO[];
-}*/
-
 export class TransactionFactory {
     /**
      * @description Generate a transaction with a custom script.
@@ -283,220 +274,6 @@ export class TransactionFactory {
         };
     }
 
-    /**
-     * Basically it's fun to manage UTXOs.
-     * @param {IWrapParameters} wrapParameters - The wrap parameters
-     * @returns {Promise<WrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     */
-    /*public async wrap(wrapParameters: Omit<IWrapParameters, 'calldata'>): Promise<WrapResult> {
-        if (wrapParameters.amount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
-            throw new Error(
-                `Amount is too low. Minimum consolidation is ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT} sat. Received ${wrapParameters.amount} sat. Make sure that you cover the unwrap consolidation fees of ${currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT}sat.`,
-            );
-        }
-
-        const childTransactionRequiredValue: bigint =
-            wrapParameters.amount +
-            currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT +
-            this.getPriorityFee(wrapParameters);
-
-        const wbtc: wBTC = new wBTC(wrapParameters.network, wrapParameters.chainId);
-        const to = wbtc.getAddress();
-        const fundingParameters: IFundingTransactionParameters = {
-            ...wrapParameters,
-            amount: childTransactionRequiredValue,
-            to: wrapParameters.to ?? to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        wrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: WrapTransaction = new WrapTransaction(wrapParameters);
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        // We add the amount
-        parameters.amount += childTransactionRequiredValue;
-        parameters.utxos = fundingParameters.utxos;
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IWrapParameters = {
-            ...wrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: WrapTransaction = new WrapTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Transaction = await finalTransaction.signTransaction();
-        return {
-            transaction: [signedTransaction.tx.toHex(), outTx.toHex()],
-            vaultAddress: finalTransaction.vault,
-            amount: finalTransaction.amount,
-            receiverAddress: finalTransaction.receiver.p2tr(wrapParameters.network),
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, wrapParameters.from, 1),
-        };
-    }*/
-
-    /**
-     * Unwrap bitcoin.
-     * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {Promise<UnwrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     * @deprecated
-     */
-    /*public async unwrapSegwit(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult> {
-        console.error('The "unwrap" method is deprecated. Use unwrapTap instead.');
-
-        const transaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(unwrapParameters);
-        await transaction.signTransaction();
-
-        const to = transaction.toAddress();
-        if (!to) throw new Error('To address is required');
-
-        // Initial generation
-        const estimatedGas = await transaction.estimateTransactionFees();
-        const estimatedFees = transaction.preEstimateTransactionFees(
-            BigInt(unwrapParameters.feeRate),
-            this.calculateNumInputs(unwrapParameters.unwrapUTXOs),
-            2n,
-            this.calculateNumSignatures(unwrapParameters.unwrapUTXOs),
-            this.maxPubKeySize(unwrapParameters.unwrapUTXOs),
-        );
-
-        const fundingParameters: IFundingTransactionParameters = {
-            ...unwrapParameters,
-            amount: estimatedGas + estimatedFees,
-            to: to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction({
-            ...unwrapParameters,
-            randomBytes: transaction.getRndBytes(),
-        });
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        parameters.utxos = fundingParameters.utxos;
-        parameters.amount = (await preTransaction.estimateTransactionFees()) + estimatedFees;
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IUnwrapParameters = {
-            ...unwrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Psbt = await finalTransaction.signPSBT();
-        const asBase64 = outTx.toBase64();
-        const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
-
-        return {
-            fundingTransaction: signedTransaction.tx.toHex(),
-            psbt: psbt,
-            feeRefundOrLoss: estimatedFees,
-            utxos: [],
-        };
-    }*/
-
-    /**
-     * Unwrap bitcoin via taproot.
-     * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {Promise<UnwrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     */
-
-    /*public async unwrap(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult> {
-        if (!unwrapParameters.from) {
-            throw new Error('Field "from" not provided.');
-        }
-
-        const transaction: UnwrapTransaction = new UnwrapTransaction(unwrapParameters);
-        await transaction.signTransaction();
-
-        const to = transaction.toAddress();
-        if (!to) throw new Error('To address is required');
-
-        // Initial generation
-        const estimatedGas = await transaction.estimateTransactionFees();
-        const fundingParameters: IFundingTransactionParameters = {
-            ...unwrapParameters,
-            amount: estimatedGas,
-            to: to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: UnwrapTransaction = new UnwrapTransaction({
-            ...unwrapParameters,
-            randomBytes: transaction.getRndBytes(),
-        });
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        parameters.utxos = fundingParameters.utxos;
-        parameters.amount =
-            (await preTransaction.estimateTransactionFees()) +
-            this.getPriorityFee(unwrapParameters);
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IUnwrapParameters = {
-            ...unwrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: UnwrapTransaction = new UnwrapTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Psbt = await finalTransaction.signPSBT();
-        const asBase64 = outTx.toBase64();
-        const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
-
-        return {
-            fundingTransaction: signedTransaction.tx.toHex(),
-            psbt: psbt,
-            feeRefundOrLoss: finalTransaction.getFeeLossOrRefund(),
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, unwrapParameters.from, 1),
-        };
-    }*/
-
     /**
      * @description Creates a funding transaction.
      * @param {IFundingTransactionParameters} parameters - The funding transaction parameters
@@ -566,36 +343,6 @@ export class TransactionFactory {
         };
     }
 
-    /*private calculateNumSignatures(vault: VaultUTXOs[]): bigint {
-        let numSignatures = 0n;
-
-        for (const v of vault) {
-            numSignatures += BigInt(v.minimum * v.utxos.length);
-        }
-
-        return numSignatures;
-    }
-
-    private calculateNumInputs(vault: VaultUTXOs[]): bigint {
-        let numSignatures = 0n;
-
-        for (const v of vault) {
-            numSignatures += BigInt(v.utxos.length);
-        }
-
-        return numSignatures;
-    }
-
-    private maxPubKeySize(vault: VaultUTXOs[]): bigint {
-        let size = 0;
-
-        for (const v of vault) {
-            size = Math.max(size, v.publicKeys.length);
-        }
-
-        return BigInt(size);
-    }*/
-
     private writePSBTHeader(type: PSBTTypes, psbt: string): string {
         const buf = Buffer.from(psbt, 'base64');
 

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

@@ -2,9 +2,7 @@ import {
     crypto as bitCrypto,
     Network,
     networks,
-    opcodes,
     Psbt,
-    PsbtInput,
     script as bitScript,
     TapScriptSig,
 } from '@btc-vision/bitcoin';
@@ -14,6 +12,7 @@ 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 {
     interface Window {
@@ -219,14 +218,10 @@ export class UnisatSigner extends CustomKeypair {
                                 viaTaproot = true;
                             }
                         }
-                    } else {
+                    } else if (canSignNonTaprootInput(input, this.publicKey)) {
                         // Non-Taproot input
-                        const script = getInputRelevantScript(input);
-
-                        if (script && pubkeyInScript(this.publicKey, script)) {
-                            needsToSign = true;
-                            viaTaproot = false;
-                        }
+                        needsToSign = true;
+                        viaTaproot = false;
                     }
 
                     if (needsToSign) {
@@ -357,37 +352,6 @@ export class UnisatSigner extends CustomKeypair {
     }
 }
 
-// Helper functions
-function isTaprootInput(input: PsbtInput): boolean {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-
-    return false;
-}
-
-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) {
-        // Additional logic can be added here if needed
-        return null;
-    }
-    return null;
-}
-
 function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }

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

@@ -1,13 +1,4 @@
-import {
-    crypto as bitCrypto,
-    script as bitScript,
-    Network,
-    networks,
-    opcodes,
-    Psbt,
-    PsbtInput,
-    TapScriptSig,
-} from '@btc-vision/bitcoin';
+import { Network, networks, Psbt, TapScriptSig } from '@btc-vision/bitcoin';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
@@ -15,6 +6,11 @@ import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions } from '../types/Unisat.js';
 import { Xverse, XverseRPCGetAccountResponse, XverseRPCSignPsbtResponse } from '../types/Xverse.js';
+import {
+    canSignNonTaprootInput,
+    isTaprootInput,
+    pubkeyInScript,
+} from '../../../signer/SignerUtils.js';
 
 declare global {
     interface Window {
@@ -226,14 +222,10 @@ export class XverseSigner extends CustomKeypair {
                                 viaTaproot = true;
                             }
                         }
-                    } else {
+                    } else if (canSignNonTaprootInput(input, this.publicKey)) {
                         // Non-Taproot input
-                        const script = getInputRelevantScript(input);
-
-                        if (script && pubkeyInScript(this.publicKey, script)) {
-                            needsToSign = true;
-                            viaTaproot = false;
-                        }
+                        needsToSign = true;
+                        viaTaproot = false;
                     }
 
                     if (needsToSign) {
@@ -376,54 +368,3 @@ export class XverseSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
-
-// Helper functions
-function isTaprootInput(input: PsbtInput): boolean {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-
-    return false;
-}
-
-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) {
-        // Additional logic can be added here if needed
-        return null;
-    }
-    return null;
-}
-
-function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
-    return pubkeyPositionInScript(pubkey, script) !== -1;
-}
-
-function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
-    const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-
-    const decompiled = bitScript.decompile(script);
-    if (decompiled === null) throw new Error('Unknown script error');
-
-    return decompiled.findIndex((element) => {
-        if (typeof element === 'number') return false;
-        return (
-            Buffer.isBuffer(element) &&
-            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly))
-        );
-    });
-}

package/src/transaction/builders/FundingTransaction.ts

@@ -1,6 +1,6 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { Signer } from '@btc-vision/bitcoin';
+import { opcodes, script, Signer } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { ECPairInterface } from 'ecpair';
 
@@ -29,9 +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([
+                Buffer.from(this.to.replace('0x', ''), 'hex'),
+                opcodes.OP_CHECKSIG,
+            ]);
+
             this.addOutput({
                 value: Number(this.amount),
-                script: Buffer.from(this.to.slice(2), 'hex'),
+                script: p2pkScript,
             });
         } else {
             this.addOutput({

package/src/transaction/builders/TransactionBuilder.ts

@@ -151,7 +151,9 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.utxos = parameters.utxos;
         this.to = parameters.to || undefined;
 
-        this.isPubKeyDestination = this.to ? this.to.startsWith('0x') : false;
+        this.isPubKeyDestination = this.to
+            ? AddressVerificator.isValidPublicKey(this.to, this.network)
+            : false;
 
         this.optionalOutputs = parameters.optionalOutputs;