opnet 1.2.20 → 1.2.22

package/browser/providers/AbstractRpcProvider.d.ts

@@ -25,10 +25,10 @@ export declare abstract class AbstractRpcProvider {
     readonly network: Network;
     private nextId;
     private chainId;
-    protected constructor(network: Network);
-    private _utxoManager;
     private gasCache;
     private lastFetchedGas;
+    protected constructor(network: Network);
+    private _utxoManager;
     get utxoManager(): UTXOsManager;
     getPublicKeyInfo(address: string): Promise<Address>;
     validateAddress(addr: string | Address, network: Network): AddressTypes | null;
@@ -37,6 +37,7 @@ export declare abstract class AbstractRpcProvider {
     getBlocks(blockNumbers: BlockTag[], prefetchTxs?: boolean): Promise<Block[]>;
     getBlockByHash(blockHash: string): Promise<Block>;
     getBalance(addressLike: string, filterOrdinals?: boolean): Promise<bigint>;
+    getBalances(addressesLike: string[], filterOrdinals?: boolean): Promise<Record<string, bigint>>;
     getTransaction(txHash: string): Promise<TransactionBase<OPNetTransactionTypes>>;
     getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
     getNetwork(): Network;
@@ -45,8 +46,8 @@ export declare abstract class AbstractRpcProvider {
     getStorageAt(address: string | Address, rawPointer: bigint | string, proofs?: boolean, height?: BigNumberish): Promise<StoredValue>;
     call(to: string | Address, data: Buffer | string, from?: Address, height?: BigNumberish, simulatedTransaction?: ParsedSimulatedTransaction, accessList?: IAccessList): Promise<CallResult | ICallRequestError>;
     gasParameters(): Promise<BlockGasParameters>;
-    private _gasParameters;
     sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
+    sendRawTransactions(txs: string[]): Promise<BroadcastedTransaction[]>;
     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>;
@@ -55,6 +56,7 @@ export declare abstract class AbstractRpcProvider {
     buildJsonRpcPayload<T extends JSONRpcMethods>(method: T, params: unknown[]): JsonRpcPayload;
     getPublicKeysInfo(addresses: string | string[] | Address | Address[]): Promise<AddressesInfo>;
     protected abstract providerUrl(url: string): string;
+    private _gasParameters;
     private parseSimulatedTransaction;
     private bufferToHex;
     private bigintToBase64;

package/browser/transactions/Transaction.d.ts

@@ -12,6 +12,7 @@ export declare abstract class TransactionBase<T extends OPNetTransactionTypes> e
     readonly index: number;
     readonly burnedBitcoin: BigNumberish;
     readonly priorityFee: BigNumberish;
+    readonly maxGasSat: BigNumberish;
     readonly inputs: TransactionInput[];
     readonly outputs: TransactionOutput[];
     readonly OPNetType: T;

package/browser/utxos/UTXOsManager.d.ts

@@ -5,11 +5,16 @@ export declare class UTXOsManager {
     private readonly provider;
     private spentUTXOs;
     private pendingUTXOs;
+    private pendingUtxoDepth;
     private lastCleanup;
+    private lastFetchTimestamp;
+    private lastFetchedData;
     constructor(provider: AbstractRpcProvider);
     spentUTXO(spent: UTXOs, newUTXOs: UTXOs): void;
     clean(): void;
     getUTXOs({ address, optimize, mergePendingUTXOs, filterSpentUTXOs, }: RequestUTXOsParams): Promise<UTXOs>;
     getUTXOsForAmount({ address, amount, optimize, mergePendingUTXOs, filterSpentUTXOs, throwErrors, }: RequestUTXOsParamsWithAmount): Promise<UTXOs>;
+    private maybeFetchUTXOs;
     private fetchUTXOs;
+    private syncPendingDepthWithFetched;
 }

package/build/providers/AbstractRpcProvider.d.ts

@@ -25,10 +25,10 @@ export declare abstract class AbstractRpcProvider {
     readonly network: Network;
     private nextId;
     private chainId;
-    protected constructor(network: Network);
-    private _utxoManager;
     private gasCache;
     private lastFetchedGas;
+    protected constructor(network: Network);
+    private _utxoManager;
     get utxoManager(): UTXOsManager;
     getPublicKeyInfo(address: string): Promise<Address>;
     validateAddress(addr: string | Address, network: Network): AddressTypes | null;
@@ -37,6 +37,7 @@ export declare abstract class AbstractRpcProvider {
     getBlocks(blockNumbers: BlockTag[], prefetchTxs?: boolean): Promise<Block[]>;
     getBlockByHash(blockHash: string): Promise<Block>;
     getBalance(addressLike: string, filterOrdinals?: boolean): Promise<bigint>;
+    getBalances(addressesLike: string[], filterOrdinals?: boolean): Promise<Record<string, bigint>>;
     getTransaction(txHash: string): Promise<TransactionBase<OPNetTransactionTypes>>;
     getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
     getNetwork(): Network;
@@ -45,8 +46,8 @@ export declare abstract class AbstractRpcProvider {
     getStorageAt(address: string | Address, rawPointer: bigint | string, proofs?: boolean, height?: BigNumberish): Promise<StoredValue>;
     call(to: string | Address, data: Buffer | string, from?: Address, height?: BigNumberish, simulatedTransaction?: ParsedSimulatedTransaction, accessList?: IAccessList): Promise<CallResult | ICallRequestError>;
     gasParameters(): Promise<BlockGasParameters>;
-    private _gasParameters;
     sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
+    sendRawTransactions(txs: string[]): Promise<BroadcastedTransaction[]>;
     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>;
@@ -55,6 +56,7 @@ export declare abstract class AbstractRpcProvider {
     buildJsonRpcPayload<T extends JSONRpcMethods>(method: T, params: unknown[]): JsonRpcPayload;
     getPublicKeysInfo(addresses: string | string[] | Address | Address[]): Promise<AddressesInfo>;
     protected abstract providerUrl(url: string): string;
+    private _gasParameters;
     private parseSimulatedTransaction;
     private bufferToHex;
     private bigintToBase64;

package/build/providers/AbstractRpcProvider.js

@@ -13,12 +13,12 @@ export class AbstractRpcProvider {
     network;
     nextId = 0;
     chainId;
+    gasCache;
+    lastFetchedGas = 0;
     constructor(network) {
         this.network = network;
     }
     _utxoManager = new UTXOsManager(this);
-    gasCache;
-    lastFetchedGas = 0;
     get utxoManager() {
         return this._utxoManager;
     }
@@ -101,6 +101,32 @@ export class AbstractRpcProvider {
         }
         return BigInt(result);
     }
+    async getBalances(addressesLike, filterOrdinals = true) {
+        const payloads = addressesLike.map((address) => {
+            return this.buildJsonRpcPayload(JSONRpcMethods.GET_BALANCE, [address, filterOrdinals]);
+        });
+        const balances = await this.callMultiplePayloads(payloads);
+        if ('error' in balances) {
+            const error = balances.error;
+            throw new Error(`Error fetching block: ${error.message}`);
+        }
+        const resultBalance = {};
+        for (let i = 0; i < balances.length; i++) {
+            const balance = balances[i];
+            const address = addressesLike[i];
+            if (!address)
+                throw new Error('Impossible index.');
+            if ('error' in balance) {
+                throw new Error(`Error fetching block: ${balance.error}`);
+            }
+            const result = balance.result;
+            if (!result || (result && !result.startsWith('0x'))) {
+                throw new Error(`Invalid balance returned from provider: ${result}`);
+            }
+            resultBalance[address] = BigInt(result);
+        }
+        return resultBalance;
+    }
     async getTransaction(txHash) {
         const payload = this.buildJsonRpcPayload(JSONRpcMethods.GET_TRANSACTION_BY_HASH, [txHash]);
         const rawTransaction = await this.callPayloadSingle(payload);
@@ -217,15 +243,6 @@ export class AbstractRpcProvider {
         }
         return this.gasCache;
     }
-    async _gasParameters() {
-        const payload = this.buildJsonRpcPayload(JSONRpcMethods.GAS, []);
-        const rawCall = await this.callPayloadSingle(payload);
-        if ('error' in rawCall) {
-            throw new Error(`Error fetching gas parameters: ${rawCall.error}`);
-        }
-        const result = rawCall.result;
-        return new BlockGasParameters(result);
-    }
     async sendRawTransaction(tx, psbt) {
         if (!/^[0-9A-Fa-f]+$/.test(tx)) {
             throw new Error('sendRawTransaction: Invalid hex string');
@@ -241,6 +258,25 @@ export class AbstractRpcProvider {
         }
         return result;
     }
+    async sendRawTransactions(txs) {
+        const payloads = txs.map((tx) => {
+            return this.buildJsonRpcPayload(JSONRpcMethods.BROADCAST_TRANSACTION, [tx, false]);
+        });
+        const rawTxs = await this.callMultiplePayloads(payloads);
+        if ('error' in rawTxs) {
+            throw new Error(`Error sending transactions: ${rawTxs.error}`);
+        }
+        return rawTxs.map((rawTx) => {
+            const result = rawTx.result;
+            if (result && result.identifier) {
+                return {
+                    ...result,
+                    identifier: BigInt(result.identifier),
+                };
+            }
+            return result;
+        });
+    }
     async getBlockWitness(height = -1, trusted, limit, page) {
         const params = [height.toString()];
         if (trusted !== undefined && trusted !== null)
@@ -332,6 +368,15 @@ export class AbstractRpcProvider {
         }
         return response;
     }
+    async _gasParameters() {
+        const payload = this.buildJsonRpcPayload(JSONRpcMethods.GAS, []);
+        const rawCall = await this.callPayloadSingle(payload);
+        if ('error' in rawCall) {
+            throw new Error(`Error fetching gas parameters: ${rawCall.error}`);
+        }
+        const result = rawCall.result;
+        return new BlockGasParameters(result);
+    }
     parseSimulatedTransaction(transaction) {
         return {
             inputs: transaction.inputs.map((input) => {

package/build/transactions/Transaction.d.ts

@@ -12,6 +12,7 @@ export declare abstract class TransactionBase<T extends OPNetTransactionTypes> e
     readonly index: number;
     readonly burnedBitcoin: BigNumberish;
     readonly priorityFee: BigNumberish;
+    readonly maxGasSat: BigNumberish;
     readonly inputs: TransactionInput[];
     readonly outputs: TransactionOutput[];
     readonly OPNetType: T;

package/build/transactions/Transaction.js

@@ -7,6 +7,7 @@ export class TransactionBase extends TransactionReceipt {
     index;
     burnedBitcoin;
     priorityFee;
+    maxGasSat;
     inputs;
     outputs;
     OPNetType;
@@ -31,6 +32,7 @@ export class TransactionBase extends TransactionReceipt {
         if (transaction.pow) {
             this.pow = this.decodeProofOfWorkChallenge(transaction.pow);
         }
+        this.maxGasSat = this.burnedBitcoin + (this.pow?.reward || 0n) - this.priorityFee;
     }
     decodeProofOfWorkChallenge(challenge) {
         return {

package/build/utxos/UTXOsManager.d.ts

@@ -5,11 +5,16 @@ export declare class UTXOsManager {
     private readonly provider;
     private spentUTXOs;
     private pendingUTXOs;
+    private pendingUtxoDepth;
     private lastCleanup;
+    private lastFetchTimestamp;
+    private lastFetchedData;
     constructor(provider: AbstractRpcProvider);
     spentUTXO(spent: UTXOs, newUTXOs: UTXOs): void;
     clean(): void;
     getUTXOs({ address, optimize, mergePendingUTXOs, filterSpentUTXOs, }: RequestUTXOsParams): Promise<UTXOs>;
     getUTXOsForAmount({ address, amount, optimize, mergePendingUTXOs, filterSpentUTXOs, throwErrors, }: RequestUTXOsParamsWithAmount): Promise<UTXOs>;
+    private maybeFetchUTXOs;
     private fetchUTXOs;
+    private syncPendingDepthWithFetched;
 }

package/build/utxos/UTXOsManager.js

@@ -1,27 +1,57 @@
 import { UTXO } from '../bitcoin/UTXOs.js';
 import { JSONRpcMethods } from '../providers/interfaces/JSONRpcMethods.js';
 const AUTO_PURGE_AFTER = 1000 * 60;
+const FETCH_COOLDOWN = 10000;
+const MEMPOOL_CHAIN_LIMIT = 25;
 export class UTXOsManager {
     provider;
     spentUTXOs = [];
     pendingUTXOs = [];
+    pendingUtxoDepth = {};
     lastCleanup = Date.now();
+    lastFetchTimestamp = 0;
+    lastFetchedData = null;
     constructor(provider) {
         this.provider = provider;
     }
     spentUTXO(spent, newUTXOs) {
-        this.pendingUTXOs = this.pendingUTXOs.filter((utxo) => !spent.some((spentUtxo) => spentUtxo.transactionId === utxo.transactionId &&
-            spentUtxo.outputIndex === utxo.outputIndex));
+        const utxoKey = (u) => `${u.transactionId}:${u.outputIndex}`;
+        this.pendingUTXOs = this.pendingUTXOs.filter((utxo) => {
+            return !spent.some((spentUtxo) => spentUtxo.transactionId === utxo.transactionId &&
+                spentUtxo.outputIndex === utxo.outputIndex);
+        });
+        for (const spentUtxo of spent) {
+            const key = utxoKey(spentUtxo);
+            delete this.pendingUtxoDepth[key];
+        }
         this.spentUTXOs.push(...spent);
-        this.pendingUTXOs.push(...newUTXOs);
+        let maxParentDepth = 0;
+        for (const spentUtxo of spent) {
+            const key = utxoKey(spentUtxo);
+            const parentDepth = this.pendingUtxoDepth[key] ?? 0;
+            if (parentDepth > maxParentDepth) {
+                maxParentDepth = parentDepth;
+            }
+        }
+        const newDepth = maxParentDepth + 1;
+        if (newDepth > MEMPOOL_CHAIN_LIMIT) {
+            throw new Error(`too-long-mempool-chain, too many descendants for tx ... [limit: ${MEMPOOL_CHAIN_LIMIT}]`);
+        }
+        for (const nu of newUTXOs) {
+            this.pendingUTXOs.push(nu);
+            this.pendingUtxoDepth[utxoKey(nu)] = newDepth;
+        }
     }
     clean() {
         this.spentUTXOs = [];
         this.pendingUTXOs = [];
+        this.pendingUtxoDepth = {};
         this.lastCleanup = Date.now();
+        this.lastFetchTimestamp = 0;
+        this.lastFetchedData = null;
     }
     async getUTXOs({ address, optimize = true, mergePendingUTXOs = true, filterSpentUTXOs = true, }) {
-        const fetchedData = await this.fetchUTXOs(address, optimize);
+        const fetchedData = await this.maybeFetchUTXOs(address, optimize);
         const utxoKey = (utxo) => `${utxo.transactionId}:${utxo.outputIndex}`;
         const pendingUTXOKeys = new Set(this.pendingUTXOs.map(utxoKey));
         const spentUTXOKeys = new Set(this.spentUTXOs.map(utxoKey));
@@ -67,8 +97,8 @@ export class UTXOsManager {
         const utxoUntilAmount = [];
         let currentValue = 0n;
         for (const utxo of combinedUTXOs) {
-            currentValue += utxo.value;
             utxoUntilAmount.push(utxo);
+            currentValue += utxo.value;
             if (currentValue >= amount) {
                 break;
             }
@@ -78,31 +108,51 @@ export class UTXOsManager {
         }
         return utxoUntilAmount;
     }
-    async fetchUTXOs(address, optimize = false) {
-        if (Date.now() - this.lastCleanup > AUTO_PURGE_AFTER) {
+    async maybeFetchUTXOs(address, optimize) {
+        const now = Date.now();
+        const age = now - this.lastFetchTimestamp;
+        if (now - this.lastCleanup > AUTO_PURGE_AFTER) {
             this.clean();
         }
+        if (this.lastFetchedData && age < FETCH_COOLDOWN) {
+            return this.lastFetchedData;
+        }
+        this.lastFetchedData = await this.fetchUTXOs(address, optimize);
+        this.lastFetchTimestamp = now;
+        this.syncPendingDepthWithFetched();
+        return this.lastFetchedData;
+    }
+    async fetchUTXOs(address, optimize = false) {
         const addressStr = address.toString();
         const payload = this.provider.buildJsonRpcPayload(JSONRpcMethods.GET_UTXOS, [addressStr, optimize]);
-        const rawUXTOs = await this.provider.callPayloadSingle(payload);
-        if ('error' in rawUXTOs) {
-            throw new Error(`Error fetching block: ${rawUXTOs.error}`);
+        const rawUTXOs = await this.provider.callPayloadSingle(payload);
+        if ('error' in rawUTXOs) {
+            throw new Error(`Error fetching block: ${rawUTXOs.error}`);
         }
-        const result = rawUXTOs.result || {
+        const result = rawUTXOs.result || {
             confirmed: [],
             pending: [],
             spentTransactions: [],
         };
         return {
-            confirmed: result.confirmed.map((utxo) => {
-                return new UTXO(utxo);
-            }),
-            pending: result.pending.map((utxo) => {
-                return new UTXO(utxo);
-            }),
-            spentTransactions: result.spentTransactions.map((utxo) => {
-                return new UTXO(utxo);
-            }),
+            confirmed: result.confirmed.map((utxo) => new UTXO(utxo)),
+            pending: result.pending.map((utxo) => new UTXO(utxo)),
+            spentTransactions: result.spentTransactions.map((utxo) => new UTXO(utxo)),
         };
     }
+    syncPendingDepthWithFetched() {
+        if (!this.lastFetchedData) {
+            return;
+        }
+        const confirmedKeys = new Set(this.lastFetchedData.confirmed.map((u) => `${u.transactionId}:${u.outputIndex}`));
+        const spentKeys = new Set(this.lastFetchedData.spentTransactions.map((u) => `${u.transactionId}:${u.outputIndex}`));
+        this.pendingUTXOs = this.pendingUTXOs.filter((u) => {
+            const key = `${u.transactionId}:${u.outputIndex}`;
+            if (confirmedKeys.has(key) || spentKeys.has(key)) {
+                delete this.pendingUtxoDepth[key];
+                return false;
+            }
+            return true;
+        });
+    }
 }

package/eslint.config.js

@@ -30,6 +30,7 @@ export default tseslint.config(
             'prefer-spread': 'off',
             '@typescript-eslint/no-empty-object-type': 'off',
             '@typescript-eslint/no-base-to-string': 'off',
+            '@typescript-eslint/no-dynamic-delete': 'off',
         },
     },
     {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opnet",
     "type": "module",
-    "version": "1.2.20",
+    "version": "1.2.22",
     "author": "OP_NET",
     "description": "The perfect library for building Bitcoin-based applications.",
     "engines": {
@@ -100,9 +100,9 @@
     },
     "dependencies": {
         "@bitcoinerlab/secp256k1": "^1.2.0",
-        "@btc-vision/bitcoin": "^6.3.4",
+        "@btc-vision/bitcoin": "^6.3.5",
         "@btc-vision/bitcoin-rpc": "^1.0.0",
-        "@btc-vision/transaction": "^1.2.8",
+        "@btc-vision/transaction": "^1.2.9",
         "@noble/hashes": "^1.7.0",
         "bignumber.js": "^9.1.2",
         "buffer": "^6.0.3",

package/src/providers/AbstractRpcProvider.ts

@@ -12,10 +12,7 @@ import { ContractData } from '../contracts/ContractData.js';
 import { IAccessList } from '../contracts/interfaces/IAccessList.js';
 import { ICallRequestError, ICallResult } from '../contracts/interfaces/ICallResult.js';
 import { IRawContract } from '../contracts/interfaces/IRawContract.js';
-import {
-    ParsedSimulatedTransaction,
-    SimulatedTransaction,
-} from '../contracts/interfaces/SimulatedTransaction.js';
+import { ParsedSimulatedTransaction, SimulatedTransaction } from '../contracts/interfaces/SimulatedTransaction.js';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
 import { IStorageValue } from '../storage/interfaces/IStorageValue.js';
 import { StoredValue } from '../storage/StoredValue.js';
@@ -45,14 +42,13 @@ import { ReorgInformation } from './interfaces/ReorgInformation.js';
 export abstract class AbstractRpcProvider {
     private nextId: number = 0;
     private chainId: bigint | undefined;
+    private gasCache: BlockGasParameters | undefined;
+    private lastFetchedGas: number = 0;
 
     protected constructor(public readonly network: Network) {}
 
     private _utxoManager: UTXOsManager = new UTXOsManager(this);
 
-    private gasCache: BlockGasParameters | undefined;
-    private lastFetchedGas: number = 0;
-
     /**
      * Get the UTXO manager.
      */
@@ -220,6 +216,51 @@ export abstract class AbstractRpcProvider {
         return BigInt(result);
     }
 
+    /**
+     * Get the bitcoin balances of multiple addresses.
+     * @param {string[]} addressesLike The addresses to get the balances of
+     * @param {boolean} filterOrdinals Whether to filter ordinals or not
+     * @description This method is used to get the balance of a bitcoin address.
+     * @returns {Record<string, bigint>} The balance of the address
+     * @example await getBalances(['bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq']);
+     */
+    public async getBalances(
+        addressesLike: string[],
+        filterOrdinals: boolean = true,
+    ): Promise<Record<string, bigint>> {
+        const payloads: JsonRpcPayload[] = addressesLike.map((address: string) => {
+            return this.buildJsonRpcPayload(JSONRpcMethods.GET_BALANCE, [address, filterOrdinals]);
+        });
+
+        const balances: JsonRpcCallResult = await this.callMultiplePayloads(payloads);
+        if ('error' in balances) {
+            const error = balances.error as JSONRpcResultError<JSONRpcMethods.GET_BALANCE>;
+
+            throw new Error(`Error fetching block: ${error.message}`);
+        }
+
+        const resultBalance: Record<string, bigint> = {};
+        for (let i = 0; i < balances.length; i++) {
+            const balance = balances[i];
+            const address = addressesLike[i];
+
+            if (!address) throw new Error('Impossible index.');
+
+            if ('error' in balance) {
+                throw new Error(`Error fetching block: ${balance.error}`);
+            }
+
+            const result = balance.result as string;
+            if (!result || (result && !result.startsWith('0x'))) {
+                throw new Error(`Invalid balance returned from provider: ${result}`);
+            }
+
+            resultBalance[address] = BigInt(result);
+        }
+
+        return resultBalance;
+    }
+
     /**
      * Get a transaction by its hash or hash id.
      * @description This method is used to get a transaction by its hash or hash id.
@@ -464,18 +505,6 @@ export abstract class AbstractRpcProvider {
         return this.gasCache;
     }
 
-    private async _gasParameters(): Promise<BlockGasParameters> {
-        const payload: JsonRpcPayload = this.buildJsonRpcPayload(JSONRpcMethods.GAS, []);
-        const rawCall: JsonRpcResult = await this.callPayloadSingle(payload);
-
-        if ('error' in rawCall) {
-            throw new Error(`Error fetching gas parameters: ${rawCall.error}`);
-        }
-
-        const result: IBlockGasParametersInput = rawCall.result as IBlockGasParametersInput;
-        return new BlockGasParameters(result);
-    }
-
     /**
      * Send a raw transaction.
      * @description This method is used to send a raw transaction.
@@ -508,6 +537,36 @@ export abstract class AbstractRpcProvider {
         return result;
     }
 
+    /**
+     * Bulk send transactions.
+     * @description This method is used to send multiple transactions at the same time.
+     * @param {string[]} txs The raw transactions to send as hex string
+     * @returns {Promise<BroadcastedTransaction[]>} The result of the transaction
+     * @throws {Error} If something went wrong while sending the transaction
+     */
+    public async sendRawTransactions(txs: string[]): Promise<BroadcastedTransaction[]> {
+        const payloads: JsonRpcPayload[] = txs.map((tx) => {
+            return this.buildJsonRpcPayload(JSONRpcMethods.BROADCAST_TRANSACTION, [tx, false]);
+        });
+
+        const rawTxs: JsonRpcCallResult = await this.callMultiplePayloads(payloads);
+        if ('error' in rawTxs) {
+            throw new Error(`Error sending transactions: ${rawTxs.error}`);
+        }
+
+        return rawTxs.map((rawTx) => {
+            const result: BroadcastedTransaction = rawTx.result as BroadcastedTransaction;
+            if (result && result.identifier) {
+                return {
+                    ...result,
+                    identifier: BigInt(result.identifier),
+                };
+            }
+
+            return result;
+        });
+    }
+
     /**
      * Get block witnesses.
      * @description This method is used to get the witnesses of a block. This proves that the action executed inside a block are valid and confirmed by the network. If the minimum number of witnesses are not met, the block is considered as potentially invalid.
@@ -587,6 +646,27 @@ export abstract class AbstractRpcProvider {
      */
     public abstract _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult>;
 
+    /**
+     * Send a single payload. This method is used to send a single payload.
+     * @param {JsonRpcPayload} payload The payload to send
+     * @returns {Promise<JsonRpcResult>} The result of the payload
+     * @throws {Error} If no data is returned
+     * @private
+     */
+    public async callPayloadSingle(payload: JsonRpcPayload): Promise<JsonRpcResult> {
+        const rawData: JsonRpcCallResult = await this._send(payload);
+        if (!rawData.length) {
+            throw new Error('No data returned');
+        }
+
+        const data = rawData.shift();
+        if (!data) {
+            throw new Error('Block not found');
+        }
+
+        return data as JSONRpc2ResponseResult<JSONRpcMethods>;
+    }
+
     /*
      * Generate parameters needed to wrap bitcoin.
      * @description This method is used to generate the parameters needed to wrap bitcoin.
@@ -611,27 +691,6 @@ export abstract class AbstractRpcProvider {
         return new WrappedGeneration(result);
     }*/
 
-    /**
-     * Send a single payload. This method is used to send a single payload.
-     * @param {JsonRpcPayload} payload The payload to send
-     * @returns {Promise<JsonRpcResult>} The result of the payload
-     * @throws {Error} If no data is returned
-     * @private
-     */
-    public async callPayloadSingle(payload: JsonRpcPayload): Promise<JsonRpcResult> {
-        const rawData: JsonRpcCallResult = await this._send(payload);
-        if (!rawData.length) {
-            throw new Error('No data returned');
-        }
-
-        const data = rawData.shift();
-        if (!data) {
-            throw new Error('Block not found');
-        }
-
-        return data as JSONRpc2ResponseResult<JSONRpcMethods>;
-    }
-
     /**
      * Send multiple payloads. This method is used to send multiple payloads.
      * @param {JsonRpcPayload[]} payloads The payloads to send
@@ -719,6 +778,18 @@ export abstract class AbstractRpcProvider {
 
     protected abstract providerUrl(url: string): string;
 
+    private async _gasParameters(): Promise<BlockGasParameters> {
+        const payload: JsonRpcPayload = this.buildJsonRpcPayload(JSONRpcMethods.GAS, []);
+        const rawCall: JsonRpcResult = await this.callPayloadSingle(payload);
+
+        if ('error' in rawCall) {
+            throw new Error(`Error fetching gas parameters: ${rawCall.error}`);
+        }
+
+        const result: IBlockGasParametersInput = rawCall.result as IBlockGasParametersInput;
+        return new BlockGasParameters(result);
+    }
+
     private parseSimulatedTransaction(
         transaction: ParsedSimulatedTransaction,
     ): SimulatedTransaction {

package/src/transactions/Transaction.ts

@@ -44,6 +44,11 @@ export abstract class TransactionBase<T extends OPNetTransactionTypes>
      */
     public readonly priorityFee: BigNumberish;
 
+    /**
+     * @description The maximum amount of gas that can be spent by the transaction.
+     */
+    public readonly maxGasSat: BigNumberish;
+
     /**
      * @description The inputs of the transaction.
      */
@@ -98,6 +103,8 @@ export abstract class TransactionBase<T extends OPNetTransactionTypes>
         if (transaction.pow) {
             this.pow = this.decodeProofOfWorkChallenge(transaction.pow as RawProofOfWorkChallenge);
         }
+
+        this.maxGasSat = this.burnedBitcoin + (this.pow?.reward || 0n) - this.priorityFee;
     }
 
     private decodeProofOfWorkChallenge(challenge: RawProofOfWorkChallenge): ProofOfWorkChallenge {