@btc-vision/transaction 1.0.0

package/build/keypair/EcKeyPair.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { BIP32Interface } from 'bip32';
+import { Network } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+import { Address } from '@btc-vision/bsi-binary';
+import { IWallet } from './interfaces/IWallet.js';
+export declare class EcKeyPair {
+    static BIP32: any;
+    static ECPair: import("ecpair").ECPairAPI;
+    static fromWIF(wif: string, network?: Network): ECPairInterface;
+    static fromPrivateKey(privateKey: Buffer, network?: Network): ECPairInterface;
+    static fromPublicKey(publicKey: Buffer, network?: Network): ECPairInterface;
+    static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): Address;
+    static verifyPubKeys(pubKeys: Buffer[], network?: Network): Buffer[];
+    static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static generateWallet(network?: Network): IWallet;
+    static verifyContractAddress(contractAddress: Address, network?: Network): boolean;
+    static getLegacyAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static generateRandomKeyPair(network?: Network): ECPairInterface;
+    static fromSeed(seed: Buffer, network?: Network): BIP32Interface;
+    static getTaprootAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getTaprootAddressFromAddress(inAddr: Address, network?: Network): Address;
+    static fromSeedKeyPair(seed: Buffer, network?: Network): ECPairInterface;
+}

package/build/keypair/EcKeyPair.js

@@ -0,0 +1,107 @@
+import bip32 from 'bip32';
+import { address, initEccLib, networks, payments } from 'bitcoinjs-lib';
+import { ECPairFactory } from 'ecpair';
+import * as ecc from 'tiny-secp256k1';
+initEccLib(ecc);
+const BIP32Factory = typeof bip32 === 'function' ? bip32 : bip32.BIP32Factory;
+export class EcKeyPair {
+    static BIP32 = BIP32Factory(ecc);
+    static ECPair = ECPairFactory(ecc);
+    static fromWIF(wif, network = networks.bitcoin) {
+        return this.ECPair.fromWIF(wif, network);
+    }
+    static fromPrivateKey(privateKey, network = networks.bitcoin) {
+        return this.ECPair.fromPrivateKey(privateKey, { network });
+    }
+    static fromPublicKey(publicKey, network = networks.bitcoin) {
+        return this.ECPair.fromPublicKey(publicKey, { network });
+    }
+    static generateMultiSigAddress(pubKeys, minimumSignatureRequired, network = networks.bitcoin) {
+        const publicKeys = this.verifyPubKeys(pubKeys, network);
+        const { address } = payments.p2wsh({
+            redeem: payments.p2ms({
+                m: minimumSignatureRequired,
+                pubkeys: publicKeys,
+                network: network,
+            }),
+            network: network,
+        });
+        if (!address) {
+            throw new Error('Failed to generate address');
+        }
+        return address;
+    }
+    static verifyPubKeys(pubKeys, network = networks.bitcoin) {
+        return pubKeys.map((pubKey) => {
+            const key = EcKeyPair.fromPublicKey(pubKey, network);
+            if (!key) {
+                throw new Error('Failed to regenerate key');
+            }
+            return key.publicKey;
+        });
+    }
+    static getP2WPKHAddress(keyPair, network = networks.bitcoin) {
+        const res = payments.p2wpkh({ pubkey: keyPair.publicKey, network: network });
+        if (!res.address) {
+            throw new Error('Failed to generate wallet');
+        }
+        return res.address;
+    }
+    static generateWallet(network = networks.bitcoin) {
+        const keyPair = this.ECPair.makeRandom({
+            network: network,
+        });
+        const wallet = this.getP2WPKHAddress(keyPair, network);
+        if (!wallet) {
+            throw new Error('Failed to generate wallet');
+        }
+        return {
+            address: wallet,
+            privateKey: keyPair.toWIF(),
+            publicKey: keyPair.publicKey.toString('hex'),
+        };
+    }
+    static verifyContractAddress(contractAddress, network = networks.bitcoin) {
+        return !!address.toOutputScript(contractAddress, network);
+    }
+    static getLegacyAddress(keyPair, network = networks.bitcoin) {
+        const wallet = payments.p2pkh({ pubkey: keyPair.publicKey, network: network });
+        if (!wallet.address) {
+            throw new Error('Failed to generate wallet');
+        }
+        return wallet.address;
+    }
+    static generateRandomKeyPair(network = networks.bitcoin) {
+        return this.ECPair.makeRandom({
+            network: network,
+        });
+    }
+    static fromSeed(seed, network = networks.bitcoin) {
+        return this.BIP32.fromSeed(seed, network);
+    }
+    static getTaprootAddress(keyPair, network = networks.bitcoin) {
+        const myXOnlyPubkey = keyPair.publicKey.slice(1, 33);
+        const output = Buffer.concat([
+            Buffer.from([0x51, 0x20]),
+            myXOnlyPubkey,
+        ]);
+        return address.fromOutputScript(output, network);
+    }
+    static getTaprootAddressFromAddress(inAddr, network = networks.bitcoin) {
+        const { address } = payments.p2tr({
+            address: inAddr,
+            network: network,
+        });
+        if (!address) {
+            throw new Error(`Failed to generate sender address for transaction`);
+        }
+        return address;
+    }
+    static fromSeedKeyPair(seed, network = networks.bitcoin) {
+        const fromSeed = this.BIP32.fromSeed(seed, network);
+        const privKey = fromSeed.privateKey;
+        if (!privKey)
+            throw new Error('Failed to generate key pair');
+        return this.ECPair.fromPrivateKey(privKey, { network });
+    }
+}

package/build/keypair/Wallet.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IWallet } from './interfaces/IWallet.js';
+import { ECPairInterface } from 'ecpair';
+import { Network } from 'bitcoinjs-lib';
+import { Address } from '@btc-vision/bsi-binary';
+export declare class Wallet {
+    readonly network: Network;
+    private readonly _keypair;
+    private readonly _p2wpkh;
+    private readonly _p2tr;
+    constructor(wallet: IWallet, network?: Network);
+    get keypair(): ECPairInterface;
+    get p2wpkh(): Address;
+    get p2tr(): Address;
+    get publicKey(): Buffer;
+}

package/build/keypair/Wallet.js

@@ -0,0 +1,30 @@
+import { EcKeyPair } from './EcKeyPair.js';
+import { networks } from 'bitcoinjs-lib';
+export class Wallet {
+    network;
+    _keypair;
+    _p2wpkh;
+    _p2tr;
+    constructor(wallet, network = networks.bitcoin) {
+        this.network = network;
+        this._keypair = EcKeyPair.fromWIF(wallet.privateKey, this.network);
+        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this._keypair, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this._keypair, this.network);
+    }
+    get keypair() {
+        if (!this._keypair)
+            throw new Error('Keypair not set');
+        return this._keypair;
+    }
+    get p2wpkh() {
+        return this._p2wpkh;
+    }
+    get p2tr() {
+        return this._p2tr;
+    }
+    get publicKey() {
+        if (!this.keypair)
+            throw new Error('Keypair not set');
+        return this.keypair.publicKey;
+    }
+}

package/build/keypair/interfaces/GeneratedWallet.d.ts

@@ -0,0 +1,5 @@
+export interface GeneratedWallet {
+    readonly address: string;
+    readonly privateKey: string;
+    readonly publicKey: string;
+}

package/build/keypair/interfaces/GeneratedWallet.js

@@ -0,0 +1 @@
+export {};

package/build/keypair/interfaces/IWallet.d.ts

@@ -0,0 +1,5 @@
+export interface IWallet {
+    readonly address: string;
+    readonly privateKey: string;
+    readonly publicKey: string;
+}

package/build/keypair/interfaces/IWallet.js

@@ -0,0 +1 @@
+export {};

package/build/metadata/ContractBaseMetadata.d.ts

@@ -0,0 +1,9 @@
+import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
+export declare abstract class ContractBaseMetadata {
+    protected network: Network;
+    protected abstract readonly address: Address;
+    protected constructor(network?: Network);
+    static getAddress(network?: Network): Address;
+    getAddress(): Address;
+}

package/build/metadata/ContractBaseMetadata.js

@@ -0,0 +1,13 @@
+import { networks } from 'bitcoinjs-lib';
+export class ContractBaseMetadata {
+    network;
+    constructor(network = networks.bitcoin) {
+        this.network = network;
+    }
+    static getAddress(network = networks.bitcoin) {
+        throw new Error('Method not implemented.');
+    }
+    getAddress() {
+        return this.address;
+    }
+}

package/build/metadata/ContractMetadataManager.d.ts

@@ -0,0 +1 @@
+export declare const ContractMetadataManager: {};

package/build/metadata/ContractMetadataManager.js

@@ -0,0 +1,9 @@
+export const ContractMetadataManager = new (class {
+    contractsMetadata;
+}), {};
+getContractMetadata(contractName, string);
+any;
+{
+    return {};
+}
+();

package/build/metadata/contracts/ContractBase.d.ts

@@ -0,0 +1,9 @@
+import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
+export declare abstract class ContractBase {
+    protected network: Network;
+    protected abstract readonly address: Address;
+    protected constructor(network?: Network);
+    static getAddress(network?: Network): string;
+    getAddress(): Address;
+}

package/build/metadata/contracts/ContractBase.js

@@ -0,0 +1,13 @@
+import { networks } from 'bitcoinjs-lib';
+export class ContractBase {
+    network;
+    constructor(network = networks.bitcoin) {
+        this.network = network;
+    }
+    static getAddress(network = networks.bitcoin) {
+        throw new Error('Method not implemented.');
+    }
+    getAddress() {
+        return this.address;
+    }
+}

package/build/metadata/contracts/ContractBaseMetadata.d.ts

@@ -0,0 +1,9 @@
+import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
+export declare abstract class ContractBaseMetadata {
+    protected network: Network;
+    protected abstract readonly address: Address;
+    protected constructor(network?: Network);
+    static getAddress(network?: Network): Address;
+    getAddress(): Address;
+}

package/build/metadata/contracts/ContractBaseMetadata.js

@@ -0,0 +1,13 @@
+import { networks } from 'bitcoinjs-lib';
+export class ContractBaseMetadata {
+    network;
+    constructor(network = networks.bitcoin) {
+        this.network = network;
+    }
+    static getAddress(network = networks.bitcoin) {
+        throw new Error('Method not implemented.');
+    }
+    getAddress() {
+        return this.address;
+    }
+}

package/build/metadata/contracts/ContractMetadataManager.js

@@ -0,0 +1 @@
+"use strict";

package/build/metadata/contracts/wBTC.d.ts

@@ -0,0 +1,12 @@
+import { Network } from 'bitcoinjs-lib';
+import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
+import { Address } from '@btc-vision/bsi-binary';
+export declare class wBTC extends ContractBaseMetadata {
+    protected network: Network;
+    readonly tokenName: string;
+    readonly tokenSymbol: string;
+    readonly decimals: number;
+    protected readonly address: Address;
+    constructor(network?: Network);
+    static getAddress(network?: Network): Address;
+}

package/build/metadata/contracts/wBTC.js

@@ -0,0 +1,26 @@
+import { networks } from 'bitcoinjs-lib';
+import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
+export class wBTC extends ContractBaseMetadata {
+    network;
+    tokenName = 'Wrapped Bitcoin';
+    tokenSymbol = 'wBTC';
+    decimals = 8;
+    address;
+    constructor(network = networks.bitcoin) {
+        super(network);
+        this.network = network;
+        this.address = wBTC.getAddress(network);
+    }
+    static getAddress(network = networks.bitcoin) {
+        switch (network) {
+            case networks.bitcoin:
+                return 'bcrt1pcw0828yjrtlrc6mkp3lkq30j7wc7slsh7k7dyh53mrs4f8d74l6qumhqp4';
+            case networks.regtest:
+                return 'bcrt1pcw0828yjrtlrc6mkp3lkq30j7wc7slsh7k7dyh53mrs4f8d74l6qumhqp4';
+            case networks.testnet:
+                return 'tb1pq64lx73fwyrdp4asvl7xt5r5qvxvt9wy82x75taqtzvd64f58nasansurj';
+            default:
+                throw new Error(`Invalid network: ${network}`);
+        }
+    }
+}

package/build/network/NetworkConverter.js

@@ -0,0 +1,14 @@
+export class NetworkConverter {
+    static toBitcoinJSNetwork(network) {
+        switch (network) {
+            case OPNetNetwork.Mainnet:
+                return networks.bitcoin;
+            case OPNetNetwork.Testnet:
+                return networks.testnet;
+            case OPNetNetwork.Regtest:
+                return networks.regtest;
+            default:
+                throw new Error(`Invalid network: ${network}`);
+        }
+    }
+}

package/build/network/NetworkInformation.d.ts

@@ -0,0 +1,6 @@
+import { IWallet } from '../keypair/interfaces/IWallet.js';
+import { BlockchainConfig } from '@btc-vision/bsi-common';
+export interface NetworkInformation {
+    readonly wallet: IWallet;
+    readonly config: BlockchainConfig;
+}

package/build/network/NetworkInformation.js

@@ -0,0 +1 @@
+export {};

package/build/opnet.d.ts

@@ -0,0 +1,22 @@
+export { version } from './_version.js';
+export * from './bytecode/Compressor.js';
+export * from './generators/Generator.js';
+export * from './generators/builders/CalldataGenerator.js';
+export * from './generators/builders/DeploymentGenerator.js';
+export * from './keypair/EcKeyPair.js';
+export * from './keypair/Wallet.js';
+export * from './keypair/interfaces/IWallet.js';
+export * from './metadata/contracts/wBTC.js';
+export * from './metadata/ContractBaseMetadata.js';
+export * from './network/NetworkInformation.js';
+export * from './signer/TweakedSigner.js';
+export * from './transaction/TransactionFactory.js';
+export * from './transaction/interfaces/ITransactionParameters.js';
+export * from './transaction/interfaces/Tap.js';
+export * from './transaction/enums/TransactionType.js';
+export * from './transaction/builders/InteractionTransaction.js';
+export * from './transaction/builders/FundingTransaction.js';
+export * from './transaction/builders/TransactionBuilder.js';
+export * from './utils/BitcoinUtils.js';
+export * from './utxo/interfaces/IUTXO.js';
+export * from './utxo/UTXOManager.js';

package/build/opnet.js

@@ -0,0 +1,22 @@
+export { version } from './_version.js';
+export * from './bytecode/Compressor.js';
+export * from './generators/Generator.js';
+export * from './generators/builders/CalldataGenerator.js';
+export * from './generators/builders/DeploymentGenerator.js';
+export * from './keypair/EcKeyPair.js';
+export * from './keypair/Wallet.js';
+export * from './keypair/interfaces/IWallet.js';
+export * from './metadata/contracts/wBTC.js';
+export * from './metadata/ContractBaseMetadata.js';
+export * from './network/NetworkInformation.js';
+export * from './signer/TweakedSigner.js';
+export * from './transaction/TransactionFactory.js';
+export * from './transaction/interfaces/ITransactionParameters.js';
+export * from './transaction/interfaces/Tap.js';
+export * from './transaction/enums/TransactionType.js';
+export * from './transaction/builders/InteractionTransaction.js';
+export * from './transaction/builders/FundingTransaction.js';
+export * from './transaction/builders/TransactionBuilder.js';
+export * from './utils/BitcoinUtils.js';
+export * from './utxo/interfaces/IUTXO.js';
+export * from './utxo/UTXOManager.js';

package/build/scripts/Regtest.d.ts

@@ -0,0 +1,2 @@
+import { NetworkInformation } from '../network/NetworkInformation.js';
+export declare const Regtest: NetworkInformation;

package/build/scripts/Regtest.js

@@ -0,0 +1,15 @@
+import { BitcoinNetwork } from '@btc-vision/bsi-common';
+export const Regtest = {
+    wallet: {
+        address: 'bcrt1qfqsr3m7vjxheghcvw4ks0fryqxfq8qzjf8fxes',
+        publicKey: '020373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c',
+        privateKey: 'cRCiYAgCBrU7hSaJBRuPqKVYXQqM5CKXbMfWHb25X4FDAWJ8Ai92',
+    },
+    config: {
+        BITCOIND_NETWORK: BitcoinNetwork.Regtest,
+        BITCOIND_HOST: '51.81.67.34',
+        BITCOIND_PORT: 9242,
+        BITCOIND_USERNAME: 'HJSiowseujhs',
+        BITCOIND_PASSWORD: 'YHEFHSDJ23JOIhjjef2ied9u290efu2930u90U',
+    },
+};

package/build/scripts/test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/scripts/test.js

@@ -0,0 +1,74 @@
+import { wBTC } from '../metadata/contracts/wBTC.js';
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { UTXOManager } from '../utxo/UTXOManager.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wBtc = new wBTC(network);
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new UTXOManager('http://localhost:9001');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('transfer'));
+function getTransferToCalldata(to, amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    addCalldata.writeAddress(to);
+    addCalldata.writeU256(amount);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+(async () => {
+    await rpc.init(Regtest.config);
+    const utxoSetting = {
+        address: wallet.p2wpkh,
+        minAmount: 10000n,
+        requestedAmount: 100000n,
+    };
+    const utxos = await utxoManager.fetchUTXO(utxoSetting);
+    console.log(`UTXOs:`, utxos);
+    if (!utxos) {
+        throw new Error('No UTXOs found');
+    }
+    const calldata = getTransferToCalldata(wBtc.getAddress(), 5000000n);
+    const interactionParameters = {
+        from: wallet.p2wpkh,
+        to: wBtc.getAddress(),
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 150,
+        priorityFee: 50000n,
+        calldata: calldata,
+    };
+    const finalTx = factory.signInteraction(interactionParameters);
+    const firstTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[0],
+    });
+    console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+    if (!firstTxBroadcast) {
+        throw new Error('Could not broadcast first transaction');
+    }
+    const secondTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[1],
+    });
+    console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+    if (!secondTxBroadcast) {
+        throw new Error('Could not broadcast second transaction');
+    }
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+})();

package/build/signer/Regtest.d.ts

@@ -0,0 +1,2 @@
+import { NetworkInformation } from '../../src/network/NetworkInformation.js';
+export declare const Regtest: NetworkInformation;

package/build/signer/Regtest.js

@@ -0,0 +1,15 @@
+import { networks } from 'bitcoinjs-lib';
+export const Regtest = {
+    wallet: {
+        address: 'bcrt1qfqsr3m7vjxheghcvw4ks0fryqxfq8qzjf8fxes',
+        publicKey: '020373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c',
+        privateKey: 'cRCiYAgCBrU7hSaJBRuPqKVYXQqM5CKXbMfWHb25X4FDAWJ8Ai92',
+    },
+    config: {
+        BITCOIND_NETWORK: networks.regtest,
+        BITCOIND_HOST: '51.81.67.34',
+        BITCOIND_PORT: 9242,
+        BITCOIND_USERNAME: 'HJSiowseujhs',
+        BITCOIND_PASSWORD: 'YHEFHSDJ23JOIhjjef2ied9u290efu2930u90U',
+    },
+};

package/build/signer/TweakedSigner.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Network, Signer } from 'bitcoinjs-lib';
+export interface TweakSettings {
+    readonly network?: Network;
+    tweakHash?: Buffer;
+}
+export declare class TweakedSigner {
+    static tweakSigner(signer: Signer, opts?: TweakSettings): Signer;
+}

package/build/signer/TweakedSigner.js

@@ -0,0 +1,22 @@
+import { initEccLib } from 'bitcoinjs-lib';
+import { tapTweakHash } from 'bitcoinjs-lib/src/payments/bip341.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import * as ecc from 'tiny-secp256k1';
+import { EcKeyPair } from '../keypair/EcKeyPair.js';
+initEccLib(ecc);
+export class TweakedSigner {
+    static tweakSigner(signer, opts = {}) {
+        let privateKey = signer.privateKey;
+        if (!privateKey) {
+            throw new Error('Private key is required for tweaking signer!');
+        }
+        if (signer.publicKey[0] === 3) {
+            privateKey = ecc.privateNegate(privateKey);
+        }
+        const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash));
+        if (!tweakedPrivateKey) {
+            throw new Error('Invalid tweaked private key!');
+        }
+        return EcKeyPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), opts.network);
+    }
+}

package/build/transaction/TransactionBuilder.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Logger } from '@btc-vision/bsi-common';
+import { Network, Payment, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { PsbtInputExtended, PsbtOutputExtended, UpdateInput } from './interfaces/Tap.js';
+import { TransactionType } from './enums/TransactionType.js';
+import { ITransactionParameters } from './interfaces/ITransactionParameters.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { UTXO } from '../utxo/interfaces/IUTXO.js';
+export declare abstract class TransactionBuilder<T extends TransactionType> extends Logger {
+    protected static readonly LOCK_LEAF_SCRIPT: Buffer;
+    protected static readonly MINIMUM_DUST: bigint;
+    abstract readonly type: T;
+    readonly logColor: string;
+    transactionFee: bigint;
+    protected readonly transaction: Psbt;
+    protected readonly inputs: PsbtInputExtended[];
+    protected readonly updateInputs: UpdateInput[];
+    protected readonly outputs: PsbtOutputExtended[];
+    protected feeOutput: PsbtOutputExtended | null;
+    protected signed: boolean;
+    protected tapData: Payment | null;
+    protected scriptData: Payment | null;
+    protected totalInputAmount: bigint;
+    protected readonly signer: Signer;
+    protected readonly network: Network;
+    protected readonly feeRate: number;
+    protected readonly priorityFee: bigint;
+    protected readonly utxos: UTXO[];
+    protected to: Address | null;
+    private _maximumFeeRate;
+    protected constructor(parameters: ITransactionParameters);
+    setDestinationAddress(address: Address): void;
+    setMaximumFeeRate(feeRate: number): void;
+    signTransaction(): string | null;
+    getTransaction(): Transaction;
+    getScriptAddress(): string;
+    getTapAddress(): string;
+    addInput(input: PsbtInputExtended): void;
+    addOutput(output: PsbtOutputExtended): void;
+    protected calculateTotalUTXOAmount(): bigint;
+    protected calculateTotalVOutAmount(): bigint;
+    protected addInputsFromUTXO(): void;
+    protected witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+    protected internalInit(): void;
+    protected abstract buildTransaction(to?: Address): void;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    protected updateInput(input: UpdateInput): void;
+    protected getWitness(): Buffer;
+    protected getTapOutput(): Buffer;
+    protected getInputs(): PsbtInputExtended[];
+    protected getOutputs(): PsbtOutputExtended[];
+    protected verifyUTXOValidity(): void;
+    protected setFeeOutput(output: PsbtOutputExtended): void;
+    protected abstract getSignerKey(): Signer;
+    protected internalPubKeyToXOnly(): Buffer;
+    protected signInputs(transaction: Psbt): void;
+    private internalBuildTransaction;
+    private estimateTransactionFees;
+}