@btc-vision/transaction 1.0.105 → 1.0.107

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -4,15 +4,17 @@ import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
 import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { VaultUTXOs } from '../processor/PsbtTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
-
+import { PsbtOutputExtended } from './Tap.js';
 export interface ITransactionParameters extends ITweakedTransactionData {
     readonly from?: Address;
-    readonly to?: Address | undefined;
+    readonly to?: Address;
     utxos: UTXO[];
 
-    nonWitnessUtxo?: Buffer | undefined;
+    nonWitnessUtxo?: Buffer;
     estimatedFees?: bigint;
 
+    optionalOutputs?: PsbtOutputExtended[];
+
     chainId?: ChainId;
 
     readonly feeRate: number;
@@ -26,19 +28,20 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
 }
 
 export interface SharedInteractionParameters extends ITransactionParameters {
-    calldata?: Buffer | undefined;
+    calldata?: Buffer;
     disableAutoRefund?: boolean;
 
     readonly randomBytes?: Buffer;
 }
 
-export interface IInteractionParameters extends SharedInteractionParameters {
+export interface IInteractionParameters
+    extends Omit<SharedInteractionParameters, 'optionalOutputs'> {
     readonly calldata: Buffer;
 
     readonly to: Address;
 }
 
-export interface IWrapParameters extends SharedInteractionParameters {
+export interface IWrapParameters extends Omit<SharedInteractionParameters, 'optionalOutputs'> {
     readonly to?: Address;
 
     readonly from: Address;
@@ -48,14 +51,13 @@ export interface IWrapParameters extends SharedInteractionParameters {
     readonly generationParameters: WrappedGeneration;
 }
 
-export interface IUnwrapParameters extends SharedInteractionParameters {
+export interface IUnwrapParameters extends Omit<SharedInteractionParameters, 'optionalOutputs'> {
     readonly unwrapUTXOs: VaultUTXOs[];
     readonly amount: bigint;
 }
 
-export interface IDeploymentParameters extends ITransactionParameters {
+export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'> {
     readonly bytecode: Buffer;
 
-    readonly to?: undefined;
     readonly randomBytes?: Buffer;
 }

package/src/transaction/processor/PsbtTransaction.ts

@@ -119,8 +119,8 @@ export class PsbtTransaction extends TweakedTransaction {
      * @description Add an input to the transaction
      * @param input
      */
-    public addInput(input: PsbtInputExtended): void {
-        this.transaction.addInput(input);
+    public addInput(input: PsbtInputExtended, checkPartialSigs: boolean = false): void {
+        this.transaction.addInput(input, checkPartialSigs);
     }
 
     /**

package/src/transaction/shared/TweakedTransaction.ts

@@ -7,8 +7,8 @@ import { PsbtInput } from 'bip174/src/lib/interfaces.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { PsbtInputExtended, TapLeafScript } from '../interfaces/Tap.js';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
-import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 import { ChainId } from '../../network/ChainId.js';
+import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 
 export interface ITweakedTransactionData {
     readonly signer: Signer;
@@ -109,17 +109,17 @@ export abstract class TweakedTransaction extends Logger {
      * Read witnesses
      * @protected
      */
-    public static readScriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
+    public static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[] {
         let offset = 0;
 
         function readSlice(n: number): Buffer {
-            const slice = buffer.subarray(offset, offset + n);
+            const slice = Buffer.subarray(offset, offset + n);
             offset += n;
             return slice;
         }
 
         function readVarInt(): number {
-            const varint = varuint.decode(buffer, offset);
+            const varint = varuint.decode(Buffer, offset);
             offset += varuint.decode.bytes;
             return varint;
         }
@@ -421,6 +421,20 @@ export abstract class TweakedTransaction extends Logger {
         }
     }
 
+    protected splitArray<T>(arr: T[], chunkSize: number): T[][] {
+        if (chunkSize <= 0) {
+            throw new Error('Chunk size must be greater than 0.');
+        }
+
+        const result: T[][] = [];
+
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            result.push(arr.slice(i, i + chunkSize));
+        }
+
+        return result;
+    }
+
     /**
      * Signs all the inputs of the transaction.
      * @param {Psbt} transaction - The transaction to sign
@@ -428,14 +442,28 @@ export abstract class TweakedTransaction extends Logger {
      * @returns {Promise<void>}
      */
     protected async signInputs(transaction: Psbt): Promise<void> {
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            const input: PsbtInput = transaction.data.inputs[i];
+        const txs: PsbtInput[] = transaction.data.inputs;
+
+        const batchSize: number = 20;
+        const batches = this.splitArray(txs, batchSize);
+
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const promises: Promise<void>[] = [];
+            const offset = i * batchSize;
+
+            for (let j = 0; j < batch.length; j++) {
+                const index = offset + j;
+                const input = batch[j];
 
-            try {
-                await this.signInput(transaction, input, i);
-            } catch (e) {
-                this.log(`Failed to sign input ${i}: ${(e as Error).stack}`);
+                try {
+                    promises.push(this.signInput(transaction, input, index));
+                } catch (e) {
+                    this.log(`Failed to sign input ${index}: ${(e as Error).stack}`);
+                }
             }
+
+            await Promise.all(promises);
         }
 
         try {

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: settings.usePendingUTXO,
             };
 
             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 {
@@ -19,6 +20,7 @@ export interface FetchUTXOParamsMultiAddress {
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
     readonly optimized?: boolean;
+    readonly usePendingUTXO?: boolean;
 }
 
 export interface RawUTXOResponse {