@btc-vision/transaction 1.0.7 → 1.0.9

package/src/tests/wrap.ts

@@ -0,0 +1,89 @@
+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 { IWrapParameters } from '../transaction/interfaces/ITransactionParameters.js';
+import { FetchUTXOParams, UTXO } from '../utxo/interfaces/IUTXO.js';
+import { wBTC } from '../metadata/contracts/wBTC.js';
+
+const network: networks.Network = networks.regtest;
+const rpc: BitcoinRPC = new BitcoinRPC();
+const wallet: Wallet = new Wallet(Regtest.wallet, network);
+
+const opnet: OPNetLimitedProvider = new OPNetLimitedProvider('http://localhost:9001');
+const factory: TransactionFactory = new TransactionFactory();
+
+const shouldMineBlock: boolean = true;
+
+async function mineBlock(): Promise<boolean> {
+    // lets mine 1 block.
+    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: bigint = 1000000n;
+const utxoSetting: FetchUTXOParams = {
+    address: wallet.p2wpkh,
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+
+const utxos: UTXO[] = 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: IWrapParameters = {
+    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/src/tests/wrapTest.ts

@@ -0,0 +1,88 @@
+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';
+import { IWrapParameters } from '../transaction/interfaces/ITransactionParameters.js';
+import { FetchUTXOParams, UTXO } from '../utxo/interfaces/IUTXO.js';
+
+const network: networks.Network = networks.testnet;
+const rpc: BitcoinRPC = new BitcoinRPC();
+const wallet: Wallet = new Wallet(Testnet.wallet, network);
+
+const opnet: OPNetLimitedProvider = new OPNetLimitedProvider('https://testnet.opnet.org');
+const factory: TransactionFactory = new TransactionFactory();
+
+const shouldMineBlock: boolean = true;
+
+async function mineBlock(): Promise<boolean> {
+    // lets mine 1 block.
+    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: bigint = 100000000n;
+const utxoSetting: FetchUTXOParams = {
+    address: wallet.p2wpkh,
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+
+const utxos: UTXO[] = 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: IWrapParameters = {
+    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/src/transaction/TransactionFactory.ts

@@ -1,12 +1,31 @@
 import { Transaction } from 'bitcoinjs-lib';
 import {
+    IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
+    IWrapParameters,
 } from './interfaces/ITransactionParameters.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { Output } from 'bitcoinjs-lib/src/transaction.js';
 import { UTXO } from '../utxo/interfaces/IUTXO.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
+import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { WrapTransaction } from './builders/WrapTransaction.js';
+
+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 class TransactionFactory {
     /**
@@ -33,7 +52,7 @@ export class TransactionFactory {
         const out: Output = signedTransaction.outs[0];
         const newUtxo: UTXO = {
             transactionId: signedTransaction.getId(),
-            outputIndex: 0,
+            outputIndex: 0, // always 0
             scriptPubKey: {
                 hex: out.script.toString('hex'),
                 address: preTransaction.getScriptAddress(),
@@ -54,4 +73,103 @@ export class TransactionFactory {
 
         return [signedTransaction.toHex(), outTx.toHex()];
     }
+
+    /**
+     * @description Generates the required transactions.
+     * @param {IDeploymentParameters} deploymentParameters - The deployment parameters
+     * @returns {DeploymentResult} - The signed transaction
+     */
+    public signDeployment(deploymentParameters: IDeploymentParameters): DeploymentResult {
+        const preTransaction: DeploymentTransaction = new DeploymentTransaction(
+            deploymentParameters,
+        );
+
+        // Initial generation
+        preTransaction.signTransaction();
+
+        const parameters: IFundingTransactionParameters =
+            preTransaction.getFundingTransactionParameters();
+
+        const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
+        const signedTransaction: Transaction = fundingTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        const out: Output = signedTransaction.outs[0];
+        const newUtxo: UTXO = {
+            transactionId: signedTransaction.getId(),
+            outputIndex: 0, // always 0
+            scriptPubKey: {
+                hex: out.script.toString('hex'),
+                address: preTransaction.getScriptAddress(),
+            },
+            value: BigInt(out.value),
+        };
+
+        const newParams: IDeploymentParameters = {
+            ...deploymentParameters,
+            utxos: [newUtxo],
+            randomBytes: preTransaction.getRndBytes(),
+        };
+
+        const finalTransaction: DeploymentTransaction = new DeploymentTransaction(newParams);
+
+        // We have to regenerate using the new utxo
+        const outTx: Transaction = finalTransaction.signTransaction();
+
+        return {
+            transaction: [signedTransaction.toHex(), outTx.toHex()],
+            contractAddress: finalTransaction.contractAddress,
+            p2trAddress: finalTransaction.p2trAddress,
+        };
+    }
+
+    public wrap(warpParameters: IWrapParameters): WrapResult {
+        const preTransaction: WrapTransaction = new WrapTransaction(warpParameters);
+
+        // Initial generation
+        preTransaction.signTransaction();
+
+        const parameters: IFundingTransactionParameters =
+            preTransaction.getFundingTransactionParameters();
+
+        // We add the amount
+        parameters.childTransactionRequiredValue += warpParameters.amount;
+
+        const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
+        const signedTransaction: Transaction = fundingTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        const out: Output = signedTransaction.outs[0];
+        const newUtxo: UTXO = {
+            transactionId: signedTransaction.getId(),
+            outputIndex: 0, // always 0
+            scriptPubKey: {
+                hex: out.script.toString('hex'),
+                address: preTransaction.getScriptAddress(),
+            },
+            value: BigInt(out.value),
+        };
+
+        const newParams: IWrapParameters = {
+            ...warpParameters,
+            utxos: [newUtxo],
+            randomBytes: preTransaction.getRndBytes(),
+        };
+
+        const finalTransaction: WrapTransaction = new WrapTransaction(newParams);
+
+        // We have to regenerate using the new utxo
+        const outTx: Transaction = finalTransaction.signTransaction();
+
+        return {
+            transaction: [signedTransaction.toHex(), outTx.toHex()],
+            vaultAddress: finalTransaction.vault,
+            amount: finalTransaction.amount,
+            receiverAddress: finalTransaction.receiver,
+        };
+    }
 }