@btc-vision/transaction 1.0.85 → 1.0.87

package/build/tests/wbtc/unwrapRegSegwit.d.ts

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

package/build/tests/wbtc/unwrapRegSegwit.js

@@ -0,0 +1,83 @@
+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 { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { PsbtTransaction } from '../../transaction/processor/PsbtTransaction.js';
+import { currentConsensusConfig } from '../../consensus/ConsensusConfig.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 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 = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: 300000n,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const unwrapAmount = currentConsensusConfig.VAULT_MINIMUM_AMOUNT;
+const unwrapUtxos = await opnet.fetchUnWrapParameters(unwrapAmount, wallet.p2tr);
+if (!unwrapUtxos) {
+    throw new Error('No UTXOs found for unwrap');
+}
+const unwrapParameters = {
+    from: wallet.p2tr,
+    utxos: utxos,
+    unwrapUTXOs: unwrapUtxos.vaultUTXOs,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 100,
+    priorityFee: 10000n,
+    amount: unwrapAmount,
+};
+const finalTx = await factory.unwrapSegwit(unwrapParameters);
+console.log(finalTx.psbt, finalTx.fundingTransaction);
+const rlSigner2 = EcKeyPair.fromPrivateKey(Buffer.from('c3878546c453bca783fd91965218242eecc32d5443764d4a7f233ff018f002e0', 'hex'), network);
+const psbtTransactionData2 = {
+    signer: rlSigner2,
+    network: network,
+};
+const removedFirstTwoChar = finalTx.psbt.slice(2);
+const psbtTransaction2 = PsbtTransaction.fromHex(removedFirstTwoChar, psbtTransactionData2);
+const s = await psbtTransaction2.attemptSignAllInputs();
+const f = psbtTransaction2.attemptFinalizeInputs(1);
+const newPsbt = psbtTransaction2.toHex();
+console.log(s, f, newPsbt);
+const realSigner = Wallet.fromWif('cRHbWamSVDkJWwjq5vMtriuFsWcptWmA7z8Nkqotk9vJ891KMBXc', network);
+const psbtTransactionData3 = {
+    signer: realSigner.keypair,
+    network: network,
+};
+const psbtTransaction3 = PsbtTransaction.fromHex(newPsbt, psbtTransactionData3);
+const s2 = await psbtTransaction3.attemptSignAllInputs();
+const f2 = psbtTransaction3.attemptFinalizeInputs(1);
+if (f2) {
+    console.log('TRANSACTION IS FINALIZED.');
+    const finalized = psbtTransaction3.final();
+    console.log('Finalized:', finalized);
+    const tx2 = await opnet.broadcastTransaction(finalTx.fundingTransaction, false);
+    console.log(`Broadcasted:`, tx2);
+    const tx3 = await opnet.broadcastTransaction(finalized, false);
+    console.log(`Broadcasted:`, tx3);
+    await mineBlock();
+}
+else {
+    throw new Error('Transaction is not finalized');
+}
+rpc.destroy();

package/build/tests/wbtc/withdrawalRequestReg.d.ts

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

package/build/tests/wbtc/withdrawalRequestReg.js

@@ -0,0 +1,71 @@
+import { wBTC } from '../../metadata/contracts/wBTC.js';
+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 { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wBtc = new wBTC(network);
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const stakeSelector = Number(`0x` + abiCoder.encodeSelector('requestWithdrawal'));
+function generateCalldata(amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(stakeSelector);
+    addCalldata.writeU256(amount);
+    return Buffer.from(addCalldata.getBuffer());
+}
+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 = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: 100000n,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const calldata = generateCalldata(600000n);
+const interactionParameters = {
+    from: wallet.p2wpkh,
+    to: wBtc.getAddress(),
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 1000,
+    priorityFee: 100000n,
+    calldata: calldata,
+};
+const finalTx = await factory.signInteraction(interactionParameters);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/wbtc/wrapReg.d.ts

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

package/build/tests/wbtc/wrapReg.js

@@ -0,0 +1,65 @@
+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 { currentConsensusConfig } from '../../consensus/ConsensusConfig.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 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 = 5n * 100000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount + currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(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: 500,
+    priorityFee: 100000n,
+    receiver: 'bcrt1ppqk36azyunxdpadza7gtf568elqxnhu3lwufg98daek3kz07390swyvzd2',
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = await 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');
+}
+rpc.destroy();
+console.log(`Wrapped ${wrapAmount} sats to ${wallet.p2tr}.`);

package/build/tests/wbtc/wrapTest.d.ts

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

package/build/tests/wbtc/wrapTest.js

@@ -0,0 +1,66 @@
+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 = 1n * 100000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(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: 500,
+    priorityFee: 50000n,
+    receiver: wallet.p2tr,
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = await 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();
+}
+rpc.destroy();

package/build/tests/withdrawalRequestReg.d.ts

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

package/build/tests/withdrawalRequestReg.js

@@ -0,0 +1,71 @@
+import { wBTC } from '../metadata/contracts/wBTC.js';
+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 { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wBtc = new wBTC(network);
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const stakeSelector = Number(`0x` + abiCoder.encodeSelector('requestWithdrawal'));
+function generateCalldata(amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(stakeSelector);
+    addCalldata.writeU256(amount);
+    return Buffer.from(addCalldata.getBuffer());
+}
+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 = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: 100000n,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const calldata = generateCalldata(252600n);
+const interactionParameters = {
+    from: wallet.p2wpkh,
+    to: wBtc.getAddress(),
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 1000,
+    priorityFee: 100000n,
+    calldata: calldata,
+};
+const finalTx = factory.signInteraction(interactionParameters);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/wrap.d.ts

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

package/build/tests/wrap.js

@@ -0,0 +1,65 @@
+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 = false;
+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: 1000,
+    priorityFee: 50000n,
+    receiver: wallet.p2tr,
+    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/wrapReg.d.ts

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

package/build/tests/wrapReg.js

@@ -0,0 +1,68 @@
+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 { currentConsensusConfig } from '../consensus/ConsensusConfig.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 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 = (currentConsensusConfig.VAULT_MINIMUM_AMOUNT * 30n) / 10n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount + currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const generationParameters = await opnet.fetchWrapParameters(wrapAmount);
+if (!generationParameters) {
+    throw new Error('No generation parameters found');
+}
+console.log(`UTXOs:`, utxos);
+const wrapParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 1000,
+    priorityFee: 100000n,
+    receiver: wallet.p2tr,
+    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();
+}
+rpc.destroy();

package/build/tests/wrapTest.d.ts

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

package/build/tests/wrapTest.js

@@ -0,0 +1,66 @@
+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 = 1n * 100000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(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: 500,
+    priorityFee: 50000n,
+    receiver: wallet.p2tr,
+    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();
+}
+rpc.destroy();

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/tests/writers/allowance.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Address } from '@btc-vision/bsi-binary';
+export declare function allowance(owner: Address, spender: Address): Buffer;

package/build/tests/writers/allowance.js

@@ -0,0 +1,10 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const abiCoder = new ABICoder();
+const allowanceSelector = Number(`0x` + abiCoder.encodeSelector('allowance'));
+export function allowance(owner, spender) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(allowanceSelector);
+    calldata.writeAddress(owner);
+    calldata.writeAddress(spender);
+    return Buffer.from(calldata.getBuffer());
+}

package/build/tests/writers/approve.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Address } from '@btc-vision/bsi-binary';
+export declare const MAX_UINT256: bigint;
+export declare function approve(spender: Address, amount?: bigint): Buffer;