@btc-vision/transaction 1.0.7 → 1.0.9

package/browser/opnet.d.ts

@@ -19,6 +19,11 @@ 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 './transaction/builders/WrapTransaction.js';
+export * from './transaction/builders/SharedInteractionTransaction.js';
+export * from './transaction/builders/DeploymentTransaction.js';
+export * from './wbtc/WrappedGenerationParameters.js';
+export * from './wbtc/Generate.js';
 export * from './utils/BitcoinUtils.js';
 export * from './utxo/interfaces/IUTXO.js';
-export * from './utxo/UTXOManager.js';
+export * from './utxo/OPNetLimitedProvider.js';

package/browser/tests/deploy.d.ts

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

package/browser/tests/wrap.d.ts

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

package/browser/tests/wrapTest.d.ts

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

package/browser/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/browser/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/browser/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;
 }

package/browser/transaction/builders/SharedInteractionTransaction.d.ts

@@ -0,0 +1,46 @@
+/// <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 { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
+    readonly randomBytes: Buffer;
+    protected targetScriptRedeem: Payment | null;
+    protected leftOverFundsScriptRedeem: Payment | null;
+    protected abstract readonly compiledTargetScript: Buffer;
+    protected abstract readonly scriptTree: Taptree;
+    protected tapLeafScript: TapLeafScript | null;
+    protected readonly calldataGenerator: CalldataGenerator;
+    protected readonly calldata: Buffer;
+    protected abstract readonly contractSecret: Buffer;
+    protected tweakedSigner?: Signer;
+    protected readonly scriptSigner: Signer;
+    protected readonly interactionPubKeys: Buffer[];
+    protected readonly minimumSignatures: number;
+    protected constructor(parameters: SharedInteractionParameters);
+    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[];
+    protected getScriptTree(): Taptree;
+    private getPubKeys;
+    private customFinalizer;
+    private getTweakerHash;
+    private getTweakedSigner;
+    private generateRedeemScripts;
+    private getLeafScript;
+}

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

@@ -5,13 +5,19 @@ 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 { ECPairInterface } from 'ecpair';
 import { Logger } from '@btc-vision/logger';
+export declare enum TransactionSequence {
+    REPLACE_BY_FEE = 4294967293,
+    FINAL = 4294967295
+}
 export declare abstract class TransactionBuilder<T extends TransactionType> extends Logger {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
     abstract readonly type: T;
     readonly logColor: string;
     transactionFee: bigint;
+    protected sequence: number;
     protected readonly transaction: Psbt;
     protected readonly inputs: PsbtInputExtended[];
     protected readonly updateInputs: UpdateInput[];
@@ -26,10 +32,11 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected readonly feeRate: number;
     protected readonly priorityFee: bigint;
     protected utxos: UTXO[];
-    protected to: Address;
+    protected to: Address | undefined;
     protected from: Address;
     private _maximumFeeRate;
     protected constructor(parameters: ITransactionParameters);
+    static getFrom(from: string | undefined, keypair: ECPairInterface, network: Network): Address;
     getFundingTransactionParameters(): IFundingTransactionParameters;
     setDestinationAddress(address: Address): void;
     setMaximumFeeRate(feeRate: number): void;

package/browser/transaction/builders/WrapTransaction.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { IWrapParameters } from '../interfaces/ITransactionParameters.js';
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
+export declare class WrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_WRAP> {
+    private static readonly WRAP_SELECTOR;
+    type: TransactionType.WBTC_WRAP;
+    readonly vault: Address;
+    readonly amount: bigint;
+    readonly receiver: Address;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly scriptTree: Taptree;
+    protected tapLeafScript: TapLeafScript | null;
+    protected readonly contractSecret: Buffer;
+    private readonly wbtc;
+    constructor(parameters: IWrapParameters);
+    private static generateMintCalldata;
+    verifyPublicKeysConstraints(generation: WrappedGeneration): boolean;
+    protected buildTransaction(): void;
+    private addVaultOutput;
+    private generateVaultAddress;
+    private generateChecksumSalt;
+}

package/browser/transaction/interfaces/ITransactionParameters.d.ts

@@ -3,9 +3,10 @@ import { Signer } from 'bitcoinjs-lib';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { Network } from 'bitcoinjs-lib/src/networks.js';
 import { Address } from '@btc-vision/bsi-binary';
+import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
 export interface ITransactionParameters {
     readonly from?: Address;
-    readonly to: Address;
+    readonly to?: Address | undefined;
     utxos: UTXO[];
     readonly signer: Signer;
     readonly network: Network;
@@ -13,21 +14,24 @@ export interface ITransactionParameters {
     readonly priorityFee: bigint;
 }
 export interface IFundingTransactionParameters extends ITransactionParameters {
-    readonly childTransactionRequiredFees: bigint;
+    childTransactionRequiredValue: bigint;
 }
-export interface IInteractionParameters extends ITransactionParameters {
-    readonly calldata: Buffer;
-    readonly pubKeys?: Buffer[];
-    readonly minimumSignatures?: number;
+export interface SharedInteractionParameters extends ITransactionParameters {
+    calldata?: Buffer | undefined;
     readonly randomBytes?: Buffer;
 }
-export interface ITransactionDataContractInteractionWrap extends IInteractionParameters {
+export interface IInteractionParameters extends SharedInteractionParameters {
+    readonly calldata: Buffer;
+    readonly to: Address;
+}
+export interface IWrapParameters extends SharedInteractionParameters {
+    readonly to?: undefined;
     readonly amount: bigint;
-    readonly minimumSignatures: number;
-    readonly pubKeys: Buffer[];
+    readonly receiver?: Address;
+    readonly generationParameters: WrappedGeneration;
 }
-export interface ITransactionDataContractDeployment extends ITransactionParameters {
+export interface IDeploymentParameters extends ITransactionParameters {
     readonly bytecode: Buffer;
-    readonly salt: Buffer;
-    readonly customSigner: Signer;
+    readonly to?: undefined;
+    readonly randomBytes?: Buffer;
 }

package/browser/utils/BitcoinUtils.d.ts

@@ -2,4 +2,5 @@
 export declare class BitcoinUtils {
     static btcToSatoshi(btc: number): BigInt;
     static rndBytes(): Buffer;
+    static opnetHash(data: Buffer): string;
 }

package/browser/utxo/OPNetLimitedProvider.d.ts

@@ -0,0 +1,10 @@
+import { FetchUTXOParams, UTXO } from './interfaces/IUTXO.js';
+import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
+export declare class OPNetLimitedProvider {
+    private readonly opnetAPIUrl;
+    private readonly utxoPath;
+    private readonly rpc;
+    constructor(opnetAPIUrl: string);
+    fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
+    fetchWrapParameters(amount: bigint): Promise<WrappedGeneration | undefined>;
+}

package/browser/wbtc/Generate.d.ts

@@ -0,0 +1,13 @@
+export interface GenerationConstraints {
+    readonly timestamp: number;
+    readonly version: string;
+    readonly minimum: number;
+    readonly transactionMinimum: number;
+}
+export interface WrappedGenerationParameters {
+    readonly keys: string[];
+    readonly vault: string;
+    readonly entities: string[];
+    readonly signature: string;
+    readonly constraints: GenerationConstraints;
+}

package/browser/wbtc/WrappedGenerationParameters.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { GenerationConstraints, WrappedGenerationParameters } from './Generate.js';
+export declare class WrappedGeneration implements WrappedGenerationParameters {
+    readonly constraints: GenerationConstraints;
+    readonly entities: string[];
+    readonly keys: string[];
+    readonly signature: string;
+    readonly vault: string;
+    readonly pubKeys: Buffer[];
+    constructor(params: WrappedGenerationParameters);
+}

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.7";
+export declare const version = "1.0.9";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.0.7';
+export const version = '1.0.9';

package/build/opnet.d.ts

@@ -19,6 +19,11 @@ 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 './transaction/builders/WrapTransaction.js';
+export * from './transaction/builders/SharedInteractionTransaction.js';
+export * from './transaction/builders/DeploymentTransaction.js';
+export * from './wbtc/WrappedGenerationParameters.js';
+export * from './wbtc/Generate.js';
 export * from './utils/BitcoinUtils.js';
 export * from './utxo/interfaces/IUTXO.js';
-export * from './utxo/UTXOManager.js';
+export * from './utxo/OPNetLimitedProvider.js';

package/build/opnet.js

@@ -19,6 +19,11 @@ 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 './transaction/builders/WrapTransaction.js';
+export * from './transaction/builders/SharedInteractionTransaction.js';
+export * from './transaction/builders/DeploymentTransaction.js';
+export * from './wbtc/WrappedGenerationParameters.js';
+export * from './wbtc/Generate.js';
 export * from './utils/BitcoinUtils.js';
 export * from './utxo/interfaces/IUTXO.js';
-export * from './utxo/UTXOManager.js';
+export * from './utxo/OPNetLimitedProvider.js';

package/build/tests/deploy.d.ts

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

package/build/tests/deploy.js

@@ -0,0 +1,60 @@
+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 * as fs from 'node:fs';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+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(Regtest.config);
+const utxoSetting = {
+    address: wallet.p2wpkh,
+    minAmount: 10000n,
+    requestedAmount: 100000n,
+};
+const utxos = await utxoManager.fetchUTXO(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const bytecode = fs.readFileSync('./bytecode/contract.wasm');
+const deploymentParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 150,
+    priorityFee: 50000n,
+    bytecode: bytecode,
+};
+const finalTx = factory.signDeployment(deploymentParameters);
+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/test.js

@@ -1,13 +1,13 @@
 import { Wallet } from '../keypair/Wallet.js';
 import { Regtest } from './Regtest.js';
-import { UTXOManager } from '../utxo/UTXOManager.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
 import { networks } from 'bitcoinjs-lib';
 import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
 import { FundingTransaction } from '../transaction/builders/FundingTransaction.js';
 const network = networks.regtest;
 const rpc = new BitcoinRPC();
 const wallet = new Wallet(Regtest.wallet, network);
-const utxoManager = new UTXOManager('http://localhost:9001');
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
 const shouldMineBlock = true;
 async function mineBlock() {
     const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
@@ -36,7 +36,7 @@ async function mineBlock() {
         network: network,
         feeRate: 150,
         priorityFee: 1000n,
-        childTransactionRequiredFees: 0n,
+        childTransactionRequiredValue: 0n,
     };
     const fundingTransaction = new FundingTransaction(interactionParameters);
     const fundingTx = fundingTransaction.signTransaction();

package/build/tests/transfer.js

@@ -1,7 +1,7 @@
 import { wBTC } from '../metadata/contracts/wBTC.js';
 import { Wallet } from '../keypair/Wallet.js';
 import { Testnet } from './Regtest.js';
-import { UTXOManager } from '../utxo/UTXOManager.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';
@@ -10,7 +10,7 @@ const network = networks.testnet;
 const rpc = new BitcoinRPC();
 const wBtc = new wBTC(network);
 const wallet = new Wallet(Testnet.wallet, network);
-const utxoManager = new UTXOManager('https://testnet.opnet.org');
+const utxoManager = new OPNetLimitedProvider('https://testnet.opnet.org');
 const factory = new TransactionFactory();
 const abiCoder = new ABICoder();
 const transferSelector = Number(`0x` + abiCoder.encodeSelector('transfer'));

package/build/tests/wrap.d.ts

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

package/build/tests/wrap.js

@@ -0,0 +1,64 @@
+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';
+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 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/tests/wrapTest.d.ts

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

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 {};