@btc-vision/transaction 1.0.96 → 1.0.99

package/build/tests/writers/approve.js

@@ -1,11 +0,0 @@
-import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
-const abiCoder = new ABICoder();
-const approveSelector = Number(`0x` + abiCoder.encodeSelector('approve'));
-export const MAX_UINT256 = 2n ** 256n - 1n;
-export function approve(spender, amount = MAX_UINT256) {
-    const calldata = new BinaryWriter();
-    calldata.writeSelector(approveSelector);
-    calldata.writeAddress(spender);
-    calldata.writeU256(amount);
-    return Buffer.from(calldata.getBuffer());
-}

package/build/transaction/TransactionBuilder.d.ts

@@ -1,60 +0,0 @@
-/// <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;
-}

package/build/transaction/TransactionBuilder.js

@@ -1,244 +0,0 @@
-import { Logger } from '@btc-vision/bsi-common';
-import { initEccLib, opcodes, payments, Psbt, script, } from 'bitcoinjs-lib';
-import { varuint } from 'bitcoinjs-lib/src/bufferutils.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 TransactionBuilder extends Logger {
-    static LOCK_LEAF_SCRIPT = script.compile([opcodes.OP_0]);
-    static MINIMUM_DUST = 330n;
-    logColor = '#785def';
-    transactionFee = 0n;
-    transaction;
-    inputs = [];
-    updateInputs = [];
-    outputs = [];
-    feeOutput = null;
-    signed = false;
-    tapData = null;
-    scriptData = null;
-    totalInputAmount;
-    signer;
-    network;
-    feeRate;
-    priorityFee;
-    utxos;
-    to = null;
-    _maximumFeeRate = 1000000;
-    constructor(parameters) {
-        super();
-        this.signer = parameters.signer;
-        this.network = parameters.network;
-        this.feeRate = parameters.feeRate;
-        this.priorityFee = parameters.priorityFee;
-        this.utxos = parameters.utxos;
-        this.to = parameters.to;
-        this.totalInputAmount = this.calculateTotalUTXOAmount();
-        const totalVOut = this.calculateTotalVOutAmount();
-        if (totalVOut < this.totalInputAmount) {
-            throw new Error(`Vout value is less than the value to send`);
-        }
-        if (this.totalInputAmount < TransactionBuilder.MINIMUM_DUST) {
-            throw new Error(`Value is less than the minimum dust`);
-        }
-        this.transaction = new Psbt({
-            network: this.network,
-        });
-    }
-    setDestinationAddress(address) {
-        this.to = address;
-    }
-    setMaximumFeeRate(feeRate) {
-        this._maximumFeeRate = feeRate;
-    }
-    signTransaction() {
-        if (!this.to)
-            throw new Error('Transaction must have a recipient');
-        if (!EcKeyPair.verifyContractAddress(this.to, this.network)) {
-            throw new Error('Invalid contract address. The contract address must be a taproot address.');
-        }
-        if (this.signed)
-            throw new Error('Transaction is already signed');
-        this.signed = true;
-        this.buildTransaction(this.to);
-        const builtTx = this.internalBuildTransaction(this.transaction);
-        if (builtTx) {
-            return this.transaction.extractTransaction(false).toHex();
-        }
-        throw new Error('Could not sign transaction');
-    }
-    getTransaction() {
-        return this.transaction.extractTransaction(false);
-    }
-    getScriptAddress() {
-        if (!this.scriptData || !this.scriptData.address) {
-            throw new Error('Tap data is required');
-        }
-        return this.scriptData.address;
-    }
-    getTapAddress() {
-        if (!this.tapData || !this.tapData.address) {
-            throw new Error('Tap data is required');
-        }
-        return this.tapData.address;
-    }
-    addInput(input) {
-        this.inputs.push(input);
-    }
-    addOutput(output) {
-        this.outputs.push(output);
-    }
-    calculateTotalUTXOAmount() {
-        let total = 0n;
-        for (let utxo of this.utxos) {
-            total += utxo.value;
-        }
-        return total;
-    }
-    calculateTotalVOutAmount() {
-        let total = 0n;
-        for (let utxo of this.utxos) {
-            total += utxo.value;
-        }
-        return total;
-    }
-    addInputsFromUTXO() {
-        for (let utxo of this.utxos) {
-            const input = {
-                hash: utxo.transactionId,
-                index: utxo.outputIndex,
-                witnessUtxo: {
-                    value: Number(utxo.value),
-                    script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
-                },
-            };
-            this.addInput(input);
-        }
-    }
-    witnessStackToScriptWitness(witness) {
-        let buffer = Buffer.allocUnsafe(0);
-        function writeSlice(slice) {
-            buffer = Buffer.concat([buffer, Buffer.from(slice)]);
-        }
-        function writeVarInt(i) {
-            const currentLen = buffer.length;
-            const varintLen = varuint.encodingLength(i);
-            buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-            varuint.encode(i, buffer, currentLen);
-        }
-        function writeVarSlice(slice) {
-            writeVarInt(slice.length);
-            writeSlice(slice);
-        }
-        function writeVector(vector) {
-            writeVarInt(vector.length);
-            vector.forEach(writeVarSlice);
-        }
-        writeVector(witness);
-        return buffer;
-    }
-    internalInit() {
-        this.verifyUTXOValidity();
-        this.scriptData = payments.p2tr(this.generateScriptAddress());
-        this.tapData = payments.p2tr(this.generateTapData());
-    }
-    generateScriptAddress() {
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-        };
-    }
-    generateTapData() {
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-        };
-    }
-    updateInput(input) {
-        this.updateInputs.push(input);
-    }
-    getWitness() {
-        if (!this.tapData || !this.tapData.witness) {
-            throw new Error('Witness is required');
-        }
-        if (this.tapData.witness.length === 0) {
-            throw new Error('Witness is empty');
-        }
-        return this.tapData.witness[this.tapData.witness.length - 1];
-    }
-    getTapOutput() {
-        if (!this.tapData || !this.tapData.output) {
-            throw new Error('Tap data is required');
-        }
-        return this.tapData.output;
-    }
-    getInputs() {
-        return this.inputs;
-    }
-    getOutputs() {
-        if (!this.feeOutput)
-            throw new Error('Fee output is required');
-        const outputs = [...this.outputs];
-        outputs.push(this.feeOutput);
-        return outputs;
-    }
-    verifyUTXOValidity() {
-        for (let utxo of this.utxos) {
-            if (!utxo.scriptPubKey) {
-                throw new Error('Address is required');
-            }
-        }
-    }
-    setFeeOutput(output) {
-        this.feeOutput = output;
-        const fee = this.estimateTransactionFees();
-        if (fee > BigInt(output.value)) {
-            throw new Error('Insufficient funds');
-        }
-        this.feeOutput.value = this.feeOutput.value - Number(fee);
-    }
-    internalPubKeyToXOnly() {
-        return toXOnly(this.signer.publicKey);
-    }
-    signInputs(transaction) {
-        transaction.signAllInputs(this.getSignerKey());
-        transaction.finalizeAllInputs();
-    }
-    internalBuildTransaction(transaction) {
-        const inputs = this.getInputs();
-        const outputs = this.getOutputs();
-        transaction.setMaximumFeeRate(this._maximumFeeRate);
-        transaction.addInputs(inputs);
-        for (let i = 0; i < this.updateInputs.length; i++) {
-            transaction.updateInput(i, this.updateInputs[i]);
-        }
-        transaction.addOutputs(outputs);
-        try {
-            this.signInputs(transaction);
-            this.transactionFee = BigInt(transaction.getFee());
-            return true;
-        }
-        catch (e) {
-            const err = e;
-            this.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
-        }
-        return false;
-    }
-    estimateTransactionFees() {
-        const fakeTx = new Psbt({
-            network: this.network,
-        });
-        const builtTx = this.internalBuildTransaction(fakeTx);
-        if (builtTx) {
-            const tx = fakeTx.extractTransaction(false);
-            const size = tx.virtualSize();
-            const fee = this.feeRate * size + 1;
-            this.log(`Transaction fee estimated to: ${fee} - ${fakeTx.getFeeRate()}`);
-            return BigInt(Math.ceil(fee));
-        }
-        else {
-            throw new Error(`Could not build transaction to estimate fee. Something went wrong while building the transaction.`);
-        }
-    }
-}

package/build/transaction/browser/BrowserSigner.d.ts

@@ -1,11 +0,0 @@
-import { Psbt, Transaction } from 'bitcoinjs-lib';
-import { Unisat } from './types/Unisat.js';
-declare global {
-    interface Window {
-        unisat?: Unisat;
-    }
-}
-export declare abstract class BrowserSigner {
-    signTransaction(transaction: Psbt): Promise<Transaction>;
-    generateSigner(): Promise<void>;
-}

package/build/transaction/browser/BrowserSigner.js

@@ -1,10 +0,0 @@
-export class BrowserSigner {
-    async signTransaction(transaction) {
-        if (!window) {
-            throw new Error('BrowserSigner can only be used in a browser environment');
-        }
-        throw new Error('Not implemented');
-    }
-    async generateSigner() {
-    }
-}

package/build/transaction/browser/extensions/Unisat.d.ts

@@ -1,54 +0,0 @@
-import { Address } from '@btc-vision/bsi-binary';
-export declare enum UnisatNetwork {
-    testnet = "testnet",
-    mainnet = "livenet",
-    regtest = "regtest"
-}
-export interface Balance {
-    readonly confirmed: number;
-    readonly unconfirmed: number;
-    readonly total: number;
-}
-export declare enum MessageType {
-    ecdsa = "ecdsa",
-    bip322 = "bip322-simple"
-}
-interface ToSignInputBase {
-    readonly index: number;
-    readonly sighashTypes?: number[];
-    readonly disableTweakSigner?: boolean;
-}
-export interface ToSignInputPublicKey extends ToSignInputBase {
-    readonly publicKey: string;
-}
-export interface ToSignInputAddress extends ToSignInputBase {
-    readonly address: Address;
-}
-export type ToSignInput = ToSignInputPublicKey | ToSignInputAddress;
-export interface PsbtSignatureOptions {
-    readonly autoFinalized?: boolean;
-    readonly toSignInputs?: ToSignInput[];
-}
-export interface Unisat {
-    sendBitcoin(toAddress: Address, satoshis: number, options: {
-        feeRate: number;
-    }): Promise<string>;
-    requestAccounts(): Promise<string[]>;
-    getNetwork(): Promise<UnisatNetwork>;
-    getAccounts(): Promise<string[]>;
-    switchNetwork(network: UnisatNetwork): Promise<void>;
-    getPublicKey(): Promise<string>;
-    getBalance(): Promise<Balance>;
-    signMessage(message: string, type?: MessageType): Promise<string>;
-    pushTx(options: {
-        rawtx: string;
-    }): Promise<string>;
-    signPsbt(psbtHex: string, psbtOptions: PsbtSignatureOptions): Promise<string>;
-    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions): Promise<string[]>;
-    pushPsbt(psbtHex: string): Promise<string>;
-    on(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
-    on(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
-    removeListener(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
-    removeListener(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
-}
-export {};

package/build/transaction/browser/extensions/Unisat.js

@@ -1,11 +0,0 @@
-export var UnisatNetwork;
-(function (UnisatNetwork) {
-    UnisatNetwork["testnet"] = "testnet";
-    UnisatNetwork["mainnet"] = "livenet";
-    UnisatNetwork["regtest"] = "regtest";
-})(UnisatNetwork || (UnisatNetwork = {}));
-export var MessageType;
-(function (MessageType) {
-    MessageType["ecdsa"] = "ecdsa";
-    MessageType["bip322"] = "bip322-simple";
-})(MessageType || (MessageType = {}));

package/build/transaction/builders/DeploymentTransactionV2.d.ts

@@ -1,36 +0,0 @@
-/// <reference types="node" />
-import { TransactionType } from '../enums/TransactionType.js';
-import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
-import { Payment, Psbt } from 'bitcoinjs-lib';
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { TapLeafScript } from '../interfaces/Tap.js';
-import { Address } from '@btc-vision/bsi-binary';
-export declare class DeploymentTransactionV2 extends TransactionBuilder<TransactionType.DEPLOYMENT> {
-    type: TransactionType.DEPLOYMENT;
-    protected readonly _contractAddress: Address;
-    protected tapLeafScript: TapLeafScript | null;
-    private targetScriptRedeem;
-    private leftOverFundsScriptRedeem;
-    private readonly compiledTargetScript;
-    private readonly scriptTree;
-    private deploymentGenerator;
-    private readonly contractSeed;
-    private readonly bytecode;
-    private readonly contractSigner;
-    private readonly randomBytes;
-    constructor(parameters: IDeploymentParameters);
-    get contractAddress(): Address;
-    get p2trAddress(): Address;
-    getRndBytes(): Buffer;
-    protected contractSignerXOnlyPubKey(): Buffer;
-    protected buildTransaction(): Promise<void>;
-    protected signInputs(transaction: Psbt): Promise<void>;
-    protected generateScriptAddress(): Payment;
-    protected generateTapData(): Payment;
-    private getContractSeed;
-    private customFinalizer;
-    private getPubKeys;
-    private generateRedeemScripts;
-    private getLeafScript;
-    private getScriptTree;
-}

package/build/transaction/builders/DeploymentTransactionV2.js

@@ -1,192 +0,0 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { crypto as bitCrypto } from 'bitcoinjs-lib';
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
-import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
-import { Compressor } from '../../bytecode/Compressor.js';
-import { AddressGenerator } from '../../generators/AddressGenerator.js';
-import { DeploymentGeneratorV2 } from '../../generators/builders/DeploymentGeneratorV2.js';
-export class DeploymentTransactionV2 extends TransactionBuilder {
-    type = TransactionType.DEPLOYMENT;
-    _contractAddress;
-    tapLeafScript = null;
-    targetScriptRedeem = null;
-    leftOverFundsScriptRedeem = null;
-    compiledTargetScript;
-    scriptTree;
-    deploymentGenerator;
-    contractSeed;
-    bytecode;
-    contractSigner;
-    randomBytes;
-    constructor(parameters) {
-        super(parameters);
-        this.bytecode = Compressor.compress(parameters.bytecode);
-        if (!this.bytecode)
-            throw new Error('Bytecode is required');
-        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
-        this.contractSeed = this.getContractSeed();
-        this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
-        this.deploymentGenerator = new DeploymentGeneratorV2(this.internalPubKeyToXOnly(), this.contractSignerXOnlyPubKey(), this.network);
-        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes);
-        this.scriptTree = this.getScriptTree();
-        this.internalInit();
-        this._contractAddress = AddressGenerator.generatePKSH(this.contractSeed, this.network);
-    }
-    get contractAddress() {
-        return this._contractAddress;
-    }
-    get p2trAddress() {
-        return this.to || this.getScriptAddress();
-    }
-    getRndBytes() {
-        return this.randomBytes;
-    }
-    contractSignerXOnlyPubKey() {
-        return toXOnly(this.contractSigner.publicKey);
-    }
-    async buildTransaction() {
-        if (!this.to) {
-            this.to = this.getScriptAddress();
-        }
-        const selectedRedeem = !!this.contractSigner
-            ? this.targetScriptRedeem
-            : this.leftOverFundsScriptRedeem;
-        if (!selectedRedeem) {
-            throw new Error('Left over funds script redeem is required');
-        }
-        if (!selectedRedeem.redeemVersion) {
-            throw new Error('Left over funds script redeem version is required');
-        }
-        if (!selectedRedeem.output) {
-            throw new Error('Left over funds script redeem output is required');
-        }
-        this.tapLeafScript = {
-            leafVersion: selectedRedeem.redeemVersion,
-            script: selectedRedeem.output,
-            controlBlock: this.getWitness(),
-        };
-        this.addInputsFromUTXO();
-        const amountSpent = this.getTransactionOPNetFee();
-        this.addOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-        await this.addRefundOutput(amountSpent);
-    }
-    async signInputs(transaction) {
-        if (!this.contractSigner) {
-            await super.signInputs(transaction);
-            return;
-        }
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
-                transaction.signInput(0, this.contractSigner);
-                transaction.signInput(0, this.getSignerKey());
-                transaction.finalizeInput(0, this.customFinalizer);
-            }
-            else {
-                transaction.signInput(i, this.getSignerKey());
-                transaction.finalizeInput(i);
-            }
-        }
-    }
-    generateScriptAddress() {
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-            scriptTree: this.scriptTree,
-        };
-    }
-    generateTapData() {
-        const selectedRedeem = !!this.contractSigner
-            ? this.targetScriptRedeem
-            : this.leftOverFundsScriptRedeem;
-        if (!selectedRedeem) {
-            throw new Error('Left over funds script redeem is required');
-        }
-        if (!this.scriptTree) {
-            throw new Error('Script tree is required');
-        }
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-            scriptTree: this.scriptTree,
-            redeem: selectedRedeem,
-        };
-    }
-    getContractSeed() {
-        if (!this.bytecode) {
-            throw new Error('Bytecode is required');
-        }
-        const deployerPubKey = this.internalPubKeyToXOnly();
-        const salt = bitCrypto.hash256(this.randomBytes);
-        const sha256OfBytecode = bitCrypto.hash256(this.bytecode);
-        const buf = Buffer.concat([deployerPubKey, salt, sha256OfBytecode]);
-        return bitCrypto.hash256(buf);
-    }
-    customFinalizer = (_inputIndex, input) => {
-        if (!this.tapLeafScript) {
-            throw new Error('Tap leaf script is required');
-        }
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
-        const chunks = this.compiledTargetScript.chunks
-            .slice(0, this.compiledTargetScript.chunks.length)
-            .reverse();
-        const scriptSolution = [
-            ...chunks,
-            this.randomBytes,
-            this.internalPubKeyToXOnly(),
-            input.tapScriptSig[0].signature,
-            input.tapScriptSig[1].signature,
-        ];
-        console.log('length', scriptSolution.length);
-        const witness = scriptSolution
-            .concat(this.tapLeafScript.script)
-            .concat(this.tapLeafScript.controlBlock);
-        return {
-            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
-        };
-    };
-    getPubKeys() {
-        const pubkeys = [this.signer.publicKey];
-        if (this.contractSigner) {
-            pubkeys.push(this.contractSigner.publicKey);
-        }
-        return pubkeys;
-    }
-    generateRedeemScripts() {
-        this.targetScriptRedeem = {
-            pubkeys: this.getPubKeys(),
-            output: this.compiledTargetScript.compiled,
-            redeemVersion: 192,
-        };
-        this.leftOverFundsScriptRedeem = {
-            pubkeys: this.getPubKeys(),
-            output: this.getLeafScript(),
-            redeemVersion: 192,
-        };
-    }
-    getLeafScript() {
-        return TransactionBuilder.LOCK_LEAF_SCRIPT;
-    }
-    getScriptTree() {
-        if (!this.bytecode) {
-            throw new Error('Contract bytecode is required');
-        }
-        this.generateRedeemScripts();
-        return [
-            {
-                output: this.compiledTargetScript.compiled,
-                version: 192,
-            },
-            {
-                output: this.getLeafScript(),
-                version: 192,
-            },
-        ];
-    }
-}

package/build/transaction/builders/GenericTransaction.d.ts

@@ -1,11 +0,0 @@
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { TransactionType } from '../enums/TransactionType.js';
-import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { Signer } from 'bitcoinjs-lib';
-export declare class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
-    readonly type: TransactionType.FUNDING;
-    protected childTransactionRequiredFees: bigint;
-    constructor(parameters: IFundingTransactionParameters);
-    protected buildTransaction(): void;
-    protected getSignerKey(): Signer;
-}

package/build/transaction/builders/GenericTransaction.js

@@ -1,23 +0,0 @@
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { TransactionType } from '../enums/TransactionType.js';
-export class FundingTransaction extends TransactionBuilder {
-    type = TransactionType.FUNDING;
-    childTransactionRequiredFees;
-    constructor(parameters) {
-        super(parameters);
-        this.childTransactionRequiredFees = parameters.childTransactionRequiredFees;
-        this.internalInit();
-    }
-    buildTransaction() {
-        this.addInputsFromUTXO();
-        const amountSpent = this.getTransactionOPNetFee() + this.childTransactionRequiredFees;
-        this.setFeeOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-        this.addRefundOutput(amountSpent);
-    }
-    getSignerKey() {
-        return this.signer;
-    }
-}