@btc-vision/transaction 1.0.105 → 1.0.106

package/src/utxo/OPNetLimitedProvider.ts

@@ -1,5 +1,7 @@
 import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
 import { currentConsensusConfig } from '../consensus/ConsensusConfig.js';
+import { IFundingTransactionParameters, TransactionFactory, Wallet } from '../opnet.js';
 import { UnwrappedGenerationParameters, WrappedGenerationParameters } from '../wbtc/Generate.js';
 import { UnwrapGeneration } from '../wbtc/UnwrapGeneration.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
@@ -11,6 +13,12 @@ import {
     UTXO,
 } from './interfaces/IUTXO.js';
 
+export interface WalletUTXOs {
+    readonly confirmed: RawUTXOResponse[];
+    readonly pending: RawUTXOResponse[];
+    readonly spentTransactions: RawUTXOResponse[];
+}
+
 /**
  * Allows to fetch UTXO data from any OPNET node
  */
@@ -18,7 +26,7 @@ export class OPNetLimitedProvider {
     private readonly utxoPath: string = 'address/utxos';
     private readonly rpc: string = 'json-rpc';
 
-    constructor(private readonly opnetAPIUrl: string) {}
+    public constructor(private readonly opnetAPIUrl: string) {}
 
     /**
      * Fetches UTXO data from the OPNET node
@@ -27,6 +35,14 @@ export class OPNetLimitedProvider {
      * @throws {Error} - If UTXOs could not be fetched
      */
     public async fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]> {
+        if (settings.usePendingUTXO === undefined) {
+            settings.usePendingUTXO = true;
+        }
+
+        if (settings.optimized === undefined) {
+            settings.optimized = true;
+        }
+
         const params = {
             method: 'GET',
             headers: {
@@ -41,12 +57,31 @@ export class OPNetLimitedProvider {
             throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
         }
 
-        const fetchedData: RawUTXOResponse[] = (await resp.json()) as RawUTXOResponse[];
-        if (fetchedData.length === 0) {
+        const fetchedData: WalletUTXOs = (await resp.json()) as WalletUTXOs;
+        const allUtxos = settings.usePendingUTXO
+            ? [...fetchedData.confirmed, ...fetchedData.pending]
+            : fetchedData.confirmed;
+
+        const unspentUTXOs: RawUTXOResponse[] = [];
+        for (const utxo of allUtxos) {
+            if (
+                fetchedData.spentTransactions.some(
+                    (spent) =>
+                        spent.transactionId === utxo.transactionId &&
+                        spent.outputIndex === utxo.outputIndex,
+                )
+            ) {
+                continue;
+            }
+
+            unspentUTXOs.push(utxo);
+        }
+
+        if (unspentUTXOs.length === 0) {
             throw new Error('No UTXO found');
         }
 
-        const meetCriteria: RawUTXOResponse[] = fetchedData.filter((utxo: RawUTXOResponse) => {
+        const meetCriteria: RawUTXOResponse[] = unspentUTXOs.filter((utxo: RawUTXOResponse) => {
             return BigInt(utxo.value) >= settings.minAmount;
         });
 
@@ -97,6 +132,7 @@ export class OPNetLimitedProvider {
                 minAmount: settings.minAmount,
                 requestedAmount: settings.requestedAmount,
                 optimized: settings.optimized,
+                usePendingUTXO: false,
             };
 
             const promise = this.fetchUTXO(params).catch(() => {
@@ -145,6 +181,52 @@ export class OPNetLimitedProvider {
         return result as BroadcastResponse;
     }
 
+    /**
+     * Splits UTXOs into smaller UTXOs
+     * @param {Wallet} wallet - The wallet to split UTXOs
+     * @param {Network} network - The network to split UTXOs
+     * @param {number} splitInputsInto - The number of UTXOs to split into
+     * @param {bigint} amountPerUTXO - The amount per UTXO
+     * @returns {Promise<BroadcastResponse | { error: string }>} - The response from the OPNET node or an error
+     */
+    public async splitUTXOs(
+        wallet: Wallet,
+        network: Network,
+        splitInputsInto: number,
+        amountPerUTXO: bigint,
+    ): Promise<BroadcastResponse | { error: string }> {
+        const utxoSetting: FetchUTXOParamsMultiAddress = {
+            addresses: [wallet.p2wpkh, wallet.p2tr],
+            minAmount: 330n,
+            requestedAmount: 1_000_000_000_000_000n,
+        };
+
+        const utxos: UTXO[] = await this.fetchUTXOMultiAddr(utxoSetting);
+        if (!utxos || !utxos.length) return { error: 'No UTXOs found' };
+
+        const amount = BigInt(splitInputsInto) * amountPerUTXO;
+
+        const fundingTransactionParameters: IFundingTransactionParameters = {
+            amount: amount,
+            feeRate: 500,
+            from: wallet.p2tr,
+            utxos: utxos,
+            signer: wallet.keypair,
+            network,
+            to: wallet.p2tr,
+            splitInputsInto,
+            priorityFee: 330n,
+        };
+
+        const transactionFactory = new TransactionFactory();
+        const fundingTx = await transactionFactory.createBTCTransfer(fundingTransactionParameters);
+
+        const broadcastResponse = await this.broadcastTransaction(fundingTx.tx, false);
+        if (!broadcastResponse) return { error: 'Could not broadcast transaction' };
+
+        return broadcastResponse;
+    }
+
     /**
      * Fetches to the OPNET node
      * @param {string} method

package/src/utxo/interfaces/IUTXO.ts

@@ -11,7 +11,8 @@ export interface FetchUTXOParams {
     readonly address: string;
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
-    readonly optimized?: boolean;
+    optimized?: boolean;
+    usePendingUTXO?: boolean;
 }
 
 export interface FetchUTXOParamsMultiAddress {