@btc-vision/transaction 1.0.6 → 1.0.8

package/build/tests/wrapTest.js

@@ -0,0 +1,64 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Testnet } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+const network = networks.testnet;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Testnet.wallet, network);
+const opnet = new OPNetLimitedProvider('https://testnet.opnet.org');
+const factory = new TransactionFactory();
+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;
+}
+await rpc.init(Testnet.config);
+const wrapAmount = 100000000n;
+const utxoSetting = {
+    address: wallet.p2wpkh,
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+const utxos = await opnet.fetchUTXO(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const generationParameters = await opnet.fetchWrapParameters(wrapAmount);
+if (!generationParameters) {
+    throw new Error('No generation parameters found');
+}
+const wrapParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 350,
+    priorityFee: 50000n,
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = factory.wrap(wrapParameters);
+console.log(`Final transaction:`, finalTx);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}

package/build/tests/wrapTestg.d.ts

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

package/build/tests/wrapTestg.js

@@ -0,0 +1,66 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { wBTC } from '../metadata/contracts/wBTC.js';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const opnet = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const wBtc = new wBTC(network);
+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;
+}
+await rpc.init(Regtest.config);
+const wrapAmount = 1000000n;
+const utxoSetting = {
+    address: wallet.p2wpkh,
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+const utxos = await opnet.fetchUTXO(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const generationParameters = await opnet.fetchWrapParameters(wrapAmount);
+if (!generationParameters) {
+    throw new Error('No generation parameters found');
+}
+const wrapParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 150,
+    priorityFee: 50000n,
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = factory.wrap(wrapParameters);
+console.log(`Final transaction:`, finalTx);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}

package/build/transaction/TransactionFactory.d.ts

@@ -1,4 +1,18 @@
-import { IInteractionParameters } from './interfaces/ITransactionParameters.js';
+import { IDeploymentParameters, IInteractionParameters, IWrapParameters } from './interfaces/ITransactionParameters.js';
+import { Address } from '@btc-vision/bsi-binary';
+export interface DeploymentResult {
+    readonly transaction: [string, string];
+    readonly contractAddress: Address;
+    readonly p2trAddress: Address;
+}
+export interface WrapResult {
+    readonly transaction: [string, string];
+    readonly vaultAddress: Address;
+    readonly amount: bigint;
+    readonly receiverAddress: Address;
+}
 export declare class TransactionFactory {
     signInteraction(interactionParameters: IInteractionParameters): [string, string];
+    signDeployment(deploymentParameters: IDeploymentParameters): DeploymentResult;
+    wrap(warpParameters: IWrapParameters): WrapResult;
 }

package/build/transaction/TransactionFactory.js

@@ -1,5 +1,7 @@
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
+import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
+import { WrapTransaction } from './builders/WrapTransaction.js';
 export class TransactionFactory {
     signInteraction(interactionParameters) {
         const preTransaction = new InteractionTransaction(interactionParameters);
@@ -29,4 +31,70 @@ export class TransactionFactory {
         const outTx = finalTransaction.signTransaction();
         return [signedTransaction.toHex(), outTx.toHex()];
     }
+    signDeployment(deploymentParameters) {
+        const preTransaction = new DeploymentTransaction(deploymentParameters);
+        preTransaction.signTransaction();
+        const parameters = preTransaction.getFundingTransactionParameters();
+        const fundingTransaction = new 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'),
+                address: preTransaction.getScriptAddress(),
+            },
+            value: BigInt(out.value),
+        };
+        const newParams = {
+            ...deploymentParameters,
+            utxos: [newUtxo],
+            randomBytes: preTransaction.getRndBytes(),
+        };
+        const finalTransaction = new DeploymentTransaction(newParams);
+        const outTx = finalTransaction.signTransaction();
+        return {
+            transaction: [signedTransaction.toHex(), outTx.toHex()],
+            contractAddress: finalTransaction.contractAddress,
+            p2trAddress: finalTransaction.p2trAddress,
+        };
+    }
+    wrap(warpParameters) {
+        const preTransaction = new WrapTransaction(warpParameters);
+        preTransaction.signTransaction();
+        const parameters = preTransaction.getFundingTransactionParameters();
+        parameters.childTransactionRequiredValue += warpParameters.amount;
+        const fundingTransaction = new 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'),
+                address: preTransaction.getScriptAddress(),
+            },
+            value: BigInt(out.value),
+        };
+        const newParams = {
+            ...warpParameters,
+            utxos: [newUtxo],
+            randomBytes: preTransaction.getRndBytes(),
+        };
+        const finalTransaction = new WrapTransaction(newParams);
+        const outTx = finalTransaction.signTransaction();
+        return {
+            transaction: [signedTransaction.toHex(), outTx.toHex()],
+            vaultAddress: finalTransaction.vault,
+            amount: finalTransaction.amount,
+            receiverAddress: finalTransaction.receiver,
+        };
+    }
 }

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

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { TransactionType } from '../enums/TransactionType.js';
+import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
+import { Payment, Psbt, Signer } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { Address } from '@btc-vision/bsi-binary';
+export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
+    type: TransactionType.DEPLOYMENT;
+    protected readonly _contractAddress: Address;
+    private targetScriptRedeem;
+    private leftOverFundsScriptRedeem;
+    private readonly compiledTargetScript;
+    private readonly scriptTree;
+    private readonly tweakedSigner;
+    private tapLeafScript;
+    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 addInputsFromUTXO(): void;
+    protected buildTransaction(): void;
+    protected signInputs(transaction: Psbt): void;
+    protected getSignerKey(): Signer;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    private getContractSeed;
+    private customFinalizer;
+    private getTweakerHash;
+    private getTweakedSigner;
+    private getPubKeys;
+    private generateRedeemScripts;
+    private getLeafScript;
+    private getScriptTree;
+}

package/build/transaction/builders/DeploymentTransaction.js

@@ -0,0 +1,216 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { crypto as bitCrypto } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { TweakedSigner } from '../../signer/TweakedSigner.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { AddressGenerator } from '../../generators/AddressGenerator.js';
+export class DeploymentTransaction extends TransactionBuilder {
+    type = TransactionType.DEPLOYMENT;
+    _contractAddress;
+    targetScriptRedeem = null;
+    leftOverFundsScriptRedeem = null;
+    compiledTargetScript;
+    scriptTree;
+    tweakedSigner;
+    tapLeafScript = null;
+    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 DeploymentGenerator(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);
+    }
+    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() || utxo.scriptPubKey.hex,
+                },
+                tapLeafScript: [this.tapLeafScript],
+                sequence: this.sequence,
+            };
+            this.addInput(input);
+        }
+    }
+    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,
+        });
+        this.addRefundOutput(amountSpent);
+    }
+    signInputs(transaction) {
+        if (!this.contractSigner) {
+            super.signInputs(transaction);
+            return;
+        }
+        transaction.signInput(0, this.contractSigner);
+        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.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 scriptSolution = [
+            this.randomBytes,
+            this.internalPubKeyToXOnly(),
+            input.tapScriptSig[0].signature,
+            input.tapScriptSig[1].signature,
+        ];
+        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.tweakSigner(this.signer, settings);
+    }
+    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,
+            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,
+                version: 192,
+            },
+            {
+                output: this.getLeafScript(),
+                version: 192,
+            },
+        ];
+    }
+}

package/build/transaction/builders/FundingTransaction.js

@@ -5,10 +5,13 @@ export class FundingTransaction extends TransactionBuilder {
     childTransactionRequiredFees;
     constructor(parameters) {
         super(parameters);
-        this.childTransactionRequiredFees = parameters.childTransactionRequiredFees;
+        this.childTransactionRequiredFees = parameters.childTransactionRequiredValue;
         this.internalInit();
     }
     buildTransaction() {
+        if (!this.to) {
+            throw new Error('Recipient address is required');
+        }
         this.addInputsFromUTXO();
         const amountSpent = this.getTransactionOPNetFee() + this.childTransactionRequiredFees;
         this.addOutput({

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

@@ -1,47 +1,14 @@
 /// <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> {
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+export declare class InteractionTransaction extends SharedInteractionTransaction<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);
-    getContractSecret(): Buffer;
-    getRndBytes(): Buffer;
-    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;
 }