opnet 1.8.2 → 1.8.4

package/browser/worker_threads-browser.js

@@ -1,10 +1,8 @@
-// Browser shim for worker_threads - not used in browser context
-// WorkerCreator.ts uses Web Workers directly in browser via isNode check
-
-class Worker {
-    constructor() {
-        throw new Error('worker_threads is not available in browser. Use Web Workers instead.');
-    }
-}
-
+//#region src/shims/worker_threads-browser.js
+var Worker = class {
+	constructor() {
+		throw new Error("worker_threads is not available in browser. Use Web Workers instead.");
+	}
+};
+//#endregion
 export { Worker };

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.8.1";
+export declare const version = "1.8.4";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.8.1';
+export const version = '1.8.4';

package/build/contracts/CallResult.d.ts

@@ -107,6 +107,7 @@ export declare class CallResult<T extends ContractDecodedObjectResult = {}, U ex
     setEvents(events: U): void;
     setCalldata(calldata: Uint8Array): void;
     toOfflineBuffer(refundAddress: string, amount: bigint): Promise<Uint8Array>;
+    private max;
     private acquire;
     private bigintMax;
     private getValuesFromAccessList;

package/build/contracts/CallResult.js

@@ -4,6 +4,19 @@ import { decodeRevertData } from '../utils/RevertDecoder.js';
 import { CallResultSerializer, NetworkName } from './CallResultSerializer.js';
 import { TransactionHelper } from './TransactionHelpper.js';
 const factory = new TransactionFactory();
+function extractPackageFailures(packageResult) {
+    const failures = [];
+    const results = packageResult.txResults;
+    for (const [submittedTxid, result] of Object.entries(results)) {
+        if (result.error) {
+            failures.push(`tx ${submittedTxid} failed: ${result.error}`);
+        }
+    }
+    if (failures.length === 0 && packageResult.packageMsg !== 'success') {
+        failures.push(`package rejected: ${packageResult.packageMsg}`);
+    }
+    return failures;
+}
 export class CallResult {
     result;
     accessList;
@@ -82,6 +95,9 @@ export class CallResult {
             sendRawTransaction: () => {
                 return Promise.reject(new Error('Cannot broadcast from offline CallResult. Export signed transaction and broadcast online.'));
             },
+            sendRawTransactionPackage: () => {
+                return Promise.reject(new Error('Cannot broadcast from offline CallResult. Export signed transaction and broadcast online.'));
+            },
             getCSV1ForAddress: () => {
                 if (!data.csvAddress) {
                     throw new Error('CSV address not available in offline data');
@@ -241,33 +257,52 @@ export class CallResult {
         };
     }
     async sendPresignedTransaction(signedTx) {
-        if (!signedTx.utxoTracking.isP2WDA) {
-            if (!signedTx.fundingTransactionRaw) {
-                throw new Error('Funding transaction not created');
+        if (signedTx.utxoTracking.isP2WDA || !signedTx.fundingTransactionRaw) {
+            const tx = await this.#provider.sendRawTransaction(signedTx.interactionTransactionRaw, false);
+            if (!tx || tx.error) {
+                throw new Error(`Error sending transaction: ${tx?.error || 'Unknown error'}`);
             }
-            const tx1 = await this.#provider.sendRawTransaction(signedTx.fundingTransactionRaw, false);
-            if (!tx1 || tx1.error) {
-                throw new Error(`Error sending transaction: ${tx1?.error || 'Unknown error'}`);
+            if (!tx.result) {
+                throw new Error('No transaction ID returned');
             }
-            if (!tx1.success) {
-                throw new Error(`Error sending transaction: ${tx1.result || 'Unknown error'}`);
+            if (!tx.success) {
+                throw new Error(`Error sending transaction: ${tx.result || 'Unknown error'}`);
+            }
+            this.#processUTXOTracking(signedTx);
+            return {
+                interactionAddress: signedTx.interactionAddress,
+                transactionId: tx.result,
+                peerAcknowledgements: tx.peers || 0,
+                newUTXOs: signedTx.nextUTXOs,
+                estimatedFees: signedTx.estimatedFees,
+                challengeSolution: signedTx.challengeSolution,
+                rawTransaction: signedTx.interactionTransactionRaw,
+                fundingUTXOs: signedTx.fundingUTXOs,
+                fundingInputUtxos: signedTx.fundingInputUtxos,
+                compiledTargetScript: signedTx.compiledTargetScript,
+            };
+        }
+        const result = await this.#provider.sendRawTransactionPackage([signedTx.fundingTransactionRaw, signedTx.interactionTransactionRaw], true);
+        if (!result.success) {
+            throw new Error(`Error sending transaction package: ${result.error || 'Unknown error'}`);
+        }
+        if (result.packageResult) {
+            const failures = extractPackageFailures(result.packageResult);
+            if (failures.length > 0) {
+                throw new Error(`Transaction package failed:\n${failures.join('\n')}`);
             }
         }
-        const tx2 = await this.#provider.sendRawTransaction(signedTx.interactionTransactionRaw, false);
-        if (!tx2 || tx2.error) {
-            throw new Error(`Error sending transaction: ${tx2?.error || 'Unknown error'}`);
-        }
-        if (!tx2.result) {
-            throw new Error('No transaction ID returned');
-        }
-        if (!tx2.success) {
-            throw new Error(`Error sending transaction: ${tx2.result || 'Unknown error'}`);
+        const interactionSeqResult = result.sequentialResults?.[1];
+        if (interactionSeqResult && !interactionSeqResult.success) {
+            throw new Error(`Interaction transaction failed: ${interactionSeqResult.error || 'Unknown error'}`);
         }
+        const interactionTxId = interactionSeqResult?.txid || signedTx.interactionTransactionRaw;
+        const peers = interactionSeqResult?.peers || 0;
         this.#processUTXOTracking(signedTx);
         return {
             interactionAddress: signedTx.interactionAddress,
-            transactionId: tx2.result,
-            peerAcknowledgements: tx2.peers || 0,
+            transactionId: interactionTxId,
+            peerAcknowledgements: peers,
             newUTXOs: signedTx.nextUTXOs,
             estimatedFees: signedTx.estimatedFees,
             challengeSolution: signedTx.challengeSolution,
@@ -392,6 +427,9 @@ export class CallResult {
             }
         }
     }
+    max(a, b) {
+        return a > b ? a : b;
+    }
     async acquire(interactionParams, amountAddition = 0n) {
         if (!this.calldata) {
             throw new Error('Calldata not set');
@@ -404,21 +442,12 @@ export class CallResult {
         const addedOuts = interactionParams.extraOutputs ?? [];
         const totalOuts = addedOuts.reduce((s, o) => s + BigInt(o.value), 0n);
         const gasFee = this.bigintMax(this.estimatedSatGas, interactionParams.minGas ?? 0n);
-        const preWant = gasFee +
-            priority +
-            amountAddition +
-            totalOuts +
-            interactionParams.maximumAllowedSatToSpend;
+        const preWant = this.max(gasFee + priority + amountAddition + totalOuts, interactionParams.maximumAllowedSatToSpend);
         let utxos = interactionParams.utxos ?? (await this.#fetchUTXOs(preWant, interactionParams));
         let refetched = false;
         while (true) {
             const miningCost = TransactionHelper.estimateMiningCost(utxos, addedOuts, this.calldata.length + 200, interactionParams.network, feeRate);
-            const want = gasFee +
-                priority +
-                amountAddition +
-                totalOuts +
-                miningCost +
-                interactionParams.maximumAllowedSatToSpend;
+            const want = this.max(gasFee + priority + amountAddition + totalOuts + miningCost, interactionParams.maximumAllowedSatToSpend);
             const have = utxos.reduce((s, u) => s + u.value, 0n);
             if (have >= want)
                 break;

package/build/contracts/interfaces/IProviderForCallResult.d.ts

@@ -2,6 +2,7 @@ import { Network } from '@btc-vision/bitcoin';
 import { Address, ChallengeSolution, IP2WSHAddress } from '@btc-vision/transaction';
 import { UTXO, UTXOs } from '../../bitcoin/UTXOs.js';
 import { BroadcastedTransaction } from '../../transactions/interfaces/BroadcastedTransaction.js';
+import { BroadcastedTransactionPackage } from '../../transactions/interfaces/BroadcastedTransactionPackage.js';
 import { RequestUTXOsParamsWithAmount } from '../../utxos/interfaces/IUTXOsManager.js';
 export interface IUTXOManagerForCallResult {
     getUTXOsForAmount(params: RequestUTXOsParamsWithAmount): Promise<UTXO[]>;
@@ -13,5 +14,6 @@ export interface IProviderForCallResult {
     readonly utxoManager: IUTXOManagerForCallResult;
     getChallenge(): Promise<ChallengeSolution>;
     sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
+    sendRawTransactionPackage(txs: string[], isPackage?: boolean): Promise<BroadcastedTransactionPackage>;
     getCSV1ForAddress(address: Address): IP2WSHAddress;
 }

package/build/opnet.d.ts

@@ -70,6 +70,7 @@ export * from './storage/interfaces/IStorageValue.js';
 export * from './storage/StoredValue.js';
 export * from './contracts/interfaces/IRawContract.js';
 export * from './transactions/interfaces/BroadcastedTransaction.js';
+export * from './transactions/interfaces/BroadcastedTransactionPackage.js';
 export * from './transactions/interfaces/ITransaction.js';
 export * from './transactions/interfaces/ITransactionReceipt.js';
 export * from './transactions/metadata/TransactionReceipt.js';

package/build/opnet.js

@@ -70,6 +70,7 @@ export * from './storage/interfaces/IStorageValue.js';
 export * from './storage/StoredValue.js';
 export * from './contracts/interfaces/IRawContract.js';
 export * from './transactions/interfaces/BroadcastedTransaction.js';
+export * from './transactions/interfaces/BroadcastedTransactionPackage.js';
 export * from './transactions/interfaces/ITransaction.js';
 export * from './transactions/interfaces/ITransactionReceipt.js';
 export * from './transactions/metadata/TransactionReceipt.js';

package/build/providers/AbstractRpcProvider.d.ts

@@ -19,6 +19,7 @@ import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes
 import { MempoolTransactionData } from '../mempool/MempoolTransactionData.js';
 import { StoredValue } from '../storage/StoredValue.js';
 import { BroadcastedTransaction } from '../transactions/interfaces/BroadcastedTransaction.js';
+import { BroadcastedTransactionPackage } from '../transactions/interfaces/BroadcastedTransactionPackage.js';
 import { TransactionReceipt } from '../transactions/metadata/TransactionReceipt.js';
 import { TransactionBase } from '../transactions/Transaction.js';
 import { UTXOsManager } from '../utxos/UTXOsManager.js';
@@ -60,6 +61,7 @@ export declare abstract class AbstractRpcProvider {
     gasParameters(): Promise<BlockGasParameters>;
     sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
     sendRawTransactions(txs: string[]): Promise<BroadcastedTransaction[]>;
+    sendRawTransactionPackage(txs: string[], isPackage?: boolean): Promise<BroadcastedTransactionPackage>;
     getBlockWitness(height?: BigNumberish, trusted?: boolean, limit?: number, page?: number): Promise<BlockWitnesses>;
     getReorg(fromBlock?: BigNumberish, toBlock?: BigNumberish): Promise<ReorgInformation[]>;
     abstract _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult>;

package/build/providers/AbstractRpcProvider.js

@@ -45,8 +45,8 @@ export class AbstractRpcProvider {
         const address = addressRaw.toString();
         try {
             const pubKeyInfo = await this.getPublicKeysInfo(address, isContract);
-            return pubKeyInfo[address] ||
-                pubKeyInfo[address.startsWith('0x') ? address.slice(2) : address];
+            return (pubKeyInfo[address] ||
+                pubKeyInfo[address.startsWith('0x') ? address.slice(2) : address]);
         }
         catch (e) {
             if (AddressVerificator.isValidPublicKey(address, this.network)) {
@@ -326,6 +326,19 @@ export class AbstractRpcProvider {
             return rawTx.result;
         });
     }
+    async sendRawTransactionPackage(txs, isPackage = true) {
+        if (!txs.length) {
+            throw new Error('sendRawTransactionPackage: txs array must not be empty');
+        }
+        for (let i = 0; i < txs.length; i++) {
+            if (!/^[0-9A-Fa-f]+$/.test(txs[i])) {
+                throw new Error(`sendRawTransactionPackage: txs[${i}] is not a valid hex string`);
+            }
+        }
+        const payload = this.buildJsonRpcPayload(JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE, [txs, isPackage]);
+        const result = await this.callPayloadSingle(payload);
+        return result.result;
+    }
     async getBlockWitness(height = -1, trusted, limit, page) {
         const params = [height.toString()];
         if (trusted !== undefined && trusted !== null)

package/build/providers/WebsocketRpcProvider.js

@@ -239,6 +239,11 @@ export class WebSocketRpcProvider extends AbstractRpcProvider {
                     2: params[0],
                     3: params[1] ?? false,
                 };
+            case JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE:
+                return {
+                    2: params[0],
+                    3: params[1] ?? true,
+                };
             case JSONRpcMethods.TRANSACTION_PREIMAGE:
                 return {};
             case JSONRpcMethods.GET_BALANCE:

package/build/providers/interfaces/JSONRpcMethods.d.ts

@@ -8,6 +8,7 @@ export declare enum JSONRpcMethods {
     GAS = "btc_gas",
     GET_TRANSACTION_BY_HASH = "btc_getTransactionByHash",
     BROADCAST_TRANSACTION = "btc_sendRawTransaction",
+    BROADCAST_TRANSACTION_PACKAGE = "btc_sendRawTransactionPackage",
     TRANSACTION_PREIMAGE = "btc_preimage",
     PUBLIC_KEY_INFO = "btc_publicKeyInfo",
     GET_UTXOS = "btc_getUTXOs",

package/build/providers/interfaces/JSONRpcMethods.js

@@ -9,6 +9,7 @@ export var JSONRpcMethods;
     JSONRpcMethods["GAS"] = "btc_gas";
     JSONRpcMethods["GET_TRANSACTION_BY_HASH"] = "btc_getTransactionByHash";
     JSONRpcMethods["BROADCAST_TRANSACTION"] = "btc_sendRawTransaction";
+    JSONRpcMethods["BROADCAST_TRANSACTION_PACKAGE"] = "btc_sendRawTransactionPackage";
     JSONRpcMethods["TRANSACTION_PREIMAGE"] = "btc_preimage";
     JSONRpcMethods["PUBLIC_KEY_INFO"] = "btc_publicKeyInfo";
     JSONRpcMethods["GET_UTXOS"] = "btc_getUTXOs";

package/build/providers/websocket/MethodMapping.js

@@ -55,6 +55,12 @@ export const METHOD_MAPPINGS = {
         requestType: 'BroadcastTransactionRequest',
         responseType: 'BroadcastTransactionResponse',
     },
+    [JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE]: {
+        requestOpcode: WebSocketRequestOpcode.BROADCAST_TRANSACTION_PACKAGE,
+        responseOpcode: WebSocketResponseOpcode.BROADCAST_PACKAGE_RESULT,
+        requestType: 'BroadcastTransactionPackageRequest',
+        responseType: 'BroadcastTransactionPackageResponse',
+    },
     [JSONRpcMethods.TRANSACTION_PREIMAGE]: {
         requestOpcode: WebSocketRequestOpcode.GET_PREIMAGE,
         responseOpcode: WebSocketResponseOpcode.PREIMAGE,

package/build/providers/websocket/types/WebSocketOpcodes.d.ts

@@ -10,6 +10,7 @@ export declare enum WebSocketRequestOpcode {
     GET_TRANSACTION_BY_HASH = 32,
     GET_TRANSACTION_RECEIPT = 33,
     BROADCAST_TRANSACTION = 34,
+    BROADCAST_TRANSACTION_PACKAGE = 39,
     GET_PREIMAGE = 35,
     GET_MEMPOOL_INFO = 36,
     GET_PENDING_TRANSACTION = 37,
@@ -43,6 +44,7 @@ export declare enum WebSocketResponseOpcode {
     TRANSACTION = 160,
     TRANSACTION_RECEIPT = 161,
     BROADCAST_RESULT = 162,
+    BROADCAST_PACKAGE_RESULT = 167,
     PREIMAGE = 163,
     MEMPOOL_INFO = 164,
     PENDING_TRANSACTION = 165,

package/build/providers/websocket/types/WebSocketOpcodes.js

@@ -11,6 +11,7 @@ export var WebSocketRequestOpcode;
     WebSocketRequestOpcode[WebSocketRequestOpcode["GET_TRANSACTION_BY_HASH"] = 32] = "GET_TRANSACTION_BY_HASH";
     WebSocketRequestOpcode[WebSocketRequestOpcode["GET_TRANSACTION_RECEIPT"] = 33] = "GET_TRANSACTION_RECEIPT";
     WebSocketRequestOpcode[WebSocketRequestOpcode["BROADCAST_TRANSACTION"] = 34] = "BROADCAST_TRANSACTION";
+    WebSocketRequestOpcode[WebSocketRequestOpcode["BROADCAST_TRANSACTION_PACKAGE"] = 39] = "BROADCAST_TRANSACTION_PACKAGE";
     WebSocketRequestOpcode[WebSocketRequestOpcode["GET_PREIMAGE"] = 35] = "GET_PREIMAGE";
     WebSocketRequestOpcode[WebSocketRequestOpcode["GET_MEMPOOL_INFO"] = 36] = "GET_MEMPOOL_INFO";
     WebSocketRequestOpcode[WebSocketRequestOpcode["GET_PENDING_TRANSACTION"] = 37] = "GET_PENDING_TRANSACTION";
@@ -45,6 +46,7 @@ export var WebSocketResponseOpcode;
     WebSocketResponseOpcode[WebSocketResponseOpcode["TRANSACTION"] = 160] = "TRANSACTION";
     WebSocketResponseOpcode[WebSocketResponseOpcode["TRANSACTION_RECEIPT"] = 161] = "TRANSACTION_RECEIPT";
     WebSocketResponseOpcode[WebSocketResponseOpcode["BROADCAST_RESULT"] = 162] = "BROADCAST_RESULT";
+    WebSocketResponseOpcode[WebSocketResponseOpcode["BROADCAST_PACKAGE_RESULT"] = 167] = "BROADCAST_PACKAGE_RESULT";
     WebSocketResponseOpcode[WebSocketResponseOpcode["PREIMAGE"] = 163] = "PREIMAGE";
     WebSocketResponseOpcode[WebSocketResponseOpcode["MEMPOOL_INFO"] = 164] = "MEMPOOL_INFO";
     WebSocketResponseOpcode[WebSocketResponseOpcode["PENDING_TRANSACTION"] = 165] = "PENDING_TRANSACTION";

package/build/transactions/interfaces/BroadcastedTransactionPackage.d.ts

@@ -0,0 +1,48 @@
+export interface SequentialBroadcastTxResult {
+    readonly txid: string;
+    readonly success: boolean;
+    readonly error?: string;
+    readonly peers?: number;
+}
+export interface BroadcastedTransactionPackage {
+    readonly success: boolean;
+    readonly error?: string;
+    readonly testResults?: readonly TestMempoolAcceptResult[];
+    readonly packageResult?: PackageResult;
+    readonly sequentialResults?: readonly SequentialBroadcastTxResult[];
+    readonly fellBackToSequential?: boolean;
+}
+export interface TestMempoolAcceptResult {
+    readonly txid: string;
+    readonly wtxid: string;
+    readonly allowed?: boolean;
+    readonly vsize?: number;
+    readonly packageError?: string;
+    readonly rejectReason?: string;
+    readonly rejectDetails?: string;
+    readonly fees?: TestMempoolAcceptFees;
+}
+export interface TestMempoolAcceptFees {
+    readonly base: number;
+    readonly effectiveFeerate: number;
+    readonly effectiveIncludes: readonly string[];
+}
+export interface PackageTxResult {
+    readonly txid: string;
+    readonly otherWtxid?: string;
+    readonly vsize?: number;
+    readonly fees?: PackageTxFees;
+    readonly error?: string;
+}
+export interface PackageTxFees {
+    readonly base: number;
+    readonly effectiveFeerate?: number;
+    readonly effectiveIncludes?: readonly string[];
+}
+export interface PackageResult {
+    readonly packageMsg: string;
+    readonly txResults: {
+        readonly [wtxid: string]: PackageTxResult;
+    };
+    readonly replacedTransactions?: readonly string[];
+}

package/build/transactions/interfaces/BroadcastedTransactionPackage.js

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