@btc-vision/transaction 1.0.0

package/cjs/transaction/TransactionFactory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionFactory = void 0;
+const FundingTransaction_js_1 = require("./builders/FundingTransaction.js");
+const InteractionTransaction_js_1 = require("./builders/InteractionTransaction.js");
+class TransactionFactory {
+    signInteraction(interactionParameters) {
+        const preTransaction = new InteractionTransaction_js_1.InteractionTransaction(interactionParameters);
+        preTransaction.signTransaction();
+        const parameters = preTransaction.getFundingTransactionParameters();
+        console.log('funding transaction parameters:', parameters);
+        const fundingTransaction = new FundingTransaction_js_1.FundingTransaction(parameters);
+        const signedTransaction = fundingTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+        const out = signedTransaction.outs[0];
+        const newUtxo = {
+            transactionId: signedTransaction.getId(),
+            outputIndex: 0,
+            scriptPubKey: {
+                hex: out.script.toString('hex'),
+            },
+            value: BigInt(out.value),
+        };
+        interactionParameters.utxos = [newUtxo];
+        console.log(`new utxo`, newUtxo);
+        const finalTransaction = new InteractionTransaction_js_1.InteractionTransaction(interactionParameters);
+        const outTx = finalTransaction.signTransaction();
+        return [signedTransaction.toHex(), outTx.toHex()];
+    }
+}
+exports.TransactionFactory = TransactionFactory;

package/cjs/transaction/builders/FundingTransaction.d.ts

@@ -0,0 +1,11 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { Signer } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+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/cjs/transaction/builders/FundingTransaction.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FundingTransaction = void 0;
+const TransactionType_js_1 = require("../enums/TransactionType.js");
+const TransactionBuilder_js_1 = require("./TransactionBuilder.js");
+class FundingTransaction extends TransactionBuilder_js_1.TransactionBuilder {
+    type = TransactionType_js_1.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;
+    }
+}
+exports.FundingTransaction = FundingTransaction;

package/cjs/transaction/builders/InteractionTransaction.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { Payment, Psbt, Signer } from 'bitcoinjs-lib';
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { ECPairInterface } from 'ecpair';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+export declare class InteractionTransaction extends TransactionBuilder<TransactionType.INTERACTION> {
+    type: TransactionType.INTERACTION;
+    readonly randomBytes: Buffer;
+    protected targetScriptRedeem: Payment | null;
+    protected leftOverFundsScriptRedeem: Payment | null;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly scriptTree: Taptree;
+    protected tapLeafScript: TapLeafScript | null;
+    protected calldataGenerator: CalldataGenerator;
+    protected readonly calldata: Buffer;
+    protected readonly contractSecret: Buffer;
+    protected tweakedSigner?: Signer;
+    protected readonly scriptSigner: Signer;
+    protected readonly interactionPubKeys: Buffer[];
+    protected readonly minimumSignatures: number;
+    constructor(parameters: IInteractionParameters);
+    protected generateSecret(): Buffer;
+    protected tweakSigner(): void;
+    protected scriptSignerXOnlyPubKey(): Buffer;
+    protected generateKeyPairFromSeed(): ECPairInterface;
+    protected addInputsFromUTXO(): void;
+    protected buildTransaction(): void;
+    protected signInputs(transaction: Psbt): void;
+    protected getSignerKey(): Signer;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    protected getScriptSolution(input: PsbtInput): Buffer[];
+    private getPubKeys;
+    private customFinalizer;
+    private getTweakerHash;
+    private getTweakedSigner;
+    private generateRedeemScripts;
+    private getLeafScript;
+    private getScriptTree;
+}

package/cjs/transaction/builders/InteractionTransaction.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionTransaction = void 0;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const TransactionBuilder_js_1 = require("./TransactionBuilder.js");
+const TransactionType_js_1 = require("../enums/TransactionType.js");
+const CalldataGenerator_js_1 = require("../../generators/builders/CalldataGenerator.js");
+const Compressor_js_1 = require("../../bytecode/Compressor.js");
+const EcKeyPair_js_1 = require("../../keypair/EcKeyPair.js");
+const BitcoinUtils_js_1 = require("../../utils/BitcoinUtils.js");
+const bip371_js_1 = require("bitcoinjs-lib/src/psbt/bip371.js");
+const TweakedSigner_js_1 = require("../../signer/TweakedSigner.js");
+class InteractionTransaction extends TransactionBuilder_js_1.TransactionBuilder {
+    type = TransactionType_js_1.TransactionType.INTERACTION;
+    randomBytes = BitcoinUtils_js_1.BitcoinUtils.rndBytes();
+    targetScriptRedeem = null;
+    leftOverFundsScriptRedeem = null;
+    compiledTargetScript;
+    scriptTree;
+    tapLeafScript = null;
+    calldataGenerator;
+    calldata;
+    contractSecret = this.generateSecret();
+    tweakedSigner;
+    scriptSigner = this.generateKeyPairFromSeed();
+    interactionPubKeys;
+    minimumSignatures;
+    constructor(parameters) {
+        super(parameters);
+        if (!parameters.calldata) {
+            throw new Error('Calldata is required');
+        }
+        this.calldata = Compressor_js_1.Compressor.compress(parameters.calldata);
+        this.interactionPubKeys = parameters.pubKeys || [];
+        this.minimumSignatures = parameters.minimumSignatures || 0;
+        this.calldataGenerator = new CalldataGenerator_js_1.CalldataGenerator(this.internalPubKeyToXOnly(), this.scriptSignerXOnlyPubKey(), this.network);
+        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, this.interactionPubKeys, this.minimumSignatures);
+        this.scriptTree = this.getScriptTree();
+        this.internalInit();
+    }
+    generateSecret() {
+        return bitcoinjs_lib_1.address.fromBech32(this.to).data;
+    }
+    tweakSigner() {
+        this.tweakedSigner = this.getTweakedSigner();
+    }
+    scriptSignerXOnlyPubKey() {
+        return (0, bip371_js_1.toXOnly)(this.scriptSigner.publicKey);
+    }
+    generateKeyPairFromSeed() {
+        return EcKeyPair_js_1.EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+    }
+    addInputsFromUTXO() {
+        if (!this.tapLeafScript)
+            throw new Error('Tap leaf script is required');
+        for (let utxo of this.utxos) {
+            const input = {
+                hash: utxo.transactionId,
+                index: utxo.outputIndex,
+                witnessUtxo: {
+                    value: Number(utxo.value),
+                    script: this.getTapOutput(),
+                },
+                tapLeafScript: [this.tapLeafScript],
+            };
+            this.addInput(input);
+        }
+    }
+    buildTransaction() {
+        const selectedRedeem = !!this.scriptSigner
+            ? 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,
+        });
+        this.addRefundOutput(amountSpent);
+    }
+    signInputs(transaction) {
+        if (!this.scriptSigner) {
+            super.signInputs(transaction);
+            return;
+        }
+        transaction.signInput(0, this.scriptSigner);
+        transaction.signInput(0, this.getSignerKey());
+        transaction.finalizeInput(0, this.customFinalizer);
+    }
+    getSignerKey() {
+        if (this.tweakedSigner) {
+            return this.tweakedSigner;
+        }
+        return this.signer;
+    }
+    generateScriptAddress() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+        };
+    }
+    generateTapData() {
+        const selectedRedeem = !!this.scriptSigner
+            ? 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,
+        };
+    }
+    getScriptSolution(input) {
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+        return [
+            this.contractSecret,
+            this.internalPubKeyToXOnly(),
+            input.tapScriptSig[0].signature,
+            input.tapScriptSig[1].signature,
+        ];
+    }
+    getPubKeys() {
+        const pubkeys = [this.signer.publicKey];
+        if (this.scriptSigner) {
+            pubkeys.push(this.scriptSigner.publicKey);
+        }
+        return pubkeys;
+    }
+    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');
+        }
+        if (!this.contractSecret) {
+            throw new Error('Contract secret is required');
+        }
+        const scriptSolution = this.getScriptSolution(input);
+        const witness = scriptSolution
+            .concat(this.tapLeafScript.script)
+            .concat(this.tapLeafScript.controlBlock);
+        return {
+            finalScriptWitness: this.witnessStackToScriptWitness(witness),
+        };
+    };
+    getTweakerHash() {
+        return this.tapData?.hash;
+    }
+    getTweakedSigner(useTweakedHash = false) {
+        const settings = {
+            network: this.network,
+        };
+        if (useTweakedHash) {
+            settings.tweakHash = this.getTweakerHash();
+        }
+        return TweakedSigner_js_1.TweakedSigner.tweakSigner(this.signer, settings);
+    }
+    generateRedeemScripts() {
+        this.targetScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.compiledTargetScript,
+            redeemVersion: 192,
+        };
+        this.leftOverFundsScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.getLeafScript(),
+            redeemVersion: 192,
+        };
+    }
+    getLeafScript() {
+        return InteractionTransaction.LOCK_LEAF_SCRIPT;
+    }
+    getScriptTree() {
+        if (!this.calldata) {
+            throw new Error('Calldata is required');
+        }
+        this.generateRedeemScripts();
+        return [
+            {
+                output: this.compiledTargetScript,
+                version: 192,
+            },
+            {
+                output: this.getLeafScript(),
+                version: 192,
+            },
+        ];
+    }
+}
+exports.InteractionTransaction = InteractionTransaction;

package/cjs/transaction/builders/TransactionBuilder.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { Network, Payment, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { PsbtInputExtended, PsbtOutputExtended, UpdateInput } from '../interfaces/Tap.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { IFundingTransactionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { Logger } from '@btc-vision/logger';
+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 utxos: UTXO[];
+    protected to: Address;
+    protected from: Address;
+    private _maximumFeeRate;
+    protected constructor(parameters: ITransactionParameters);
+    getFundingTransactionParameters(): IFundingTransactionParameters;
+    setDestinationAddress(address: Address): void;
+    setMaximumFeeRate(feeRate: number): void;
+    signTransaction(): Transaction;
+    getTransaction(): Transaction;
+    getScriptAddress(): string;
+    getTapAddress(): string;
+    addInput(input: PsbtInputExtended): void;
+    addOutput(output: PsbtOutputExtended): void;
+    protected addRefundOutput(amountSpent: bigint): void;
+    protected getTransactionOPNetFee(): bigint;
+    protected calculateTotalUTXOAmount(): bigint;
+    protected calculateTotalVOutAmount(): bigint;
+    protected addInputsFromUTXO(): void;
+    protected witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+    protected internalInit(): void;
+    protected abstract buildTransaction(): 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;
+}