@btc-vision/transaction 1.2.4 → 1.2.5

package/browser/transaction/TransactionFactory.d.ts

@@ -6,6 +6,7 @@ import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import { IChallengeSolutionTransactionParameters, IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
 import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
+import { InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
@@ -38,6 +39,13 @@ export interface BitcoinTransferBase {
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
 }
+export interface InteractionResponse {
+    readonly fundingTransaction: string;
+    readonly interactionTransaction: string;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+    readonly preimage: string;
+}
 export interface ChallengeSolution extends BitcoinTransferBase {
     readonly original: ChallengeSolutionTransaction;
 }
@@ -46,11 +54,12 @@ export interface BitcoinTransferResponse extends BitcoinTransferBase {
 }
 export declare class TransactionFactory {
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters): Promise<[string, string, UTXO[]]>;
-    signInteraction(interactionParameters: IInteractionParameters): Promise<[string, string, UTXO[], string]>;
+    signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
     createChallengeSolution(parameters: IChallengeSolutionTransactionParameters): Promise<ChallengeSolution>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];
+    private detectInteractionOPWallet;
     private _createChallengeSolution;
     private createFundTransaction;
     private writePSBTHeader;

package/browser/transaction/browser/Web3Provider.d.ts

@@ -1,6 +1,6 @@
 import { IDeploymentParameters, IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { DeploymentResult } from '../TransactionFactory';
+import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer'>;
 export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network'>;
 export interface BroadcastTransactionOptions {
@@ -15,8 +15,8 @@ export interface BroadcastedTransaction {
     readonly identifier: bigint | string;
 }
 export interface Web3Provider {
-    signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[string, string, UTXO[]]>;
-    signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[]]>;
+    signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<InteractionResponse>;
+    signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[], string]>;
     deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
 }

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.2.3";
+export declare const version = "1.2.5";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.2.3';
+export const version = '1.2.5';

package/build/buffer/BinaryWriter.js

@@ -8,27 +8,27 @@ export class BinaryWriter {
     }
     writeU8(value) {
         if (value > 255)
-            throw new Error('Value is too large.');
+            throw new Error('u8 value is too large.');
         this.allocSafe(U8_BYTE_LENGTH);
         this.buffer.setUint8(this.currentOffset++, value);
     }
     writeU16(value) {
         if (value > 65535)
-            throw new Error('Value is too large.');
+            throw new Error('u16 value is too large.');
         this.allocSafe(U16_BYTE_LENGTH);
         this.buffer.setUint16(this.currentOffset, value, true);
         this.currentOffset += 2;
     }
     writeU32(value, le = true) {
         if (value > 4294967295)
-            throw new Error('Value is too large.');
+            throw new Error('u32 value is too large.');
         this.allocSafe(U32_BYTE_LENGTH);
         this.buffer.setUint32(this.currentOffset, value, le);
         this.currentOffset += 4;
     }
     writeU64(value) {
         if (value > 18446744073709551615n)
-            throw new Error('Value is too large.');
+            throw new Error('u64 value is too large.');
         this.allocSafe(U64_BYTE_LENGTH);
         this.buffer.setBigUint64(this.currentOffset, value, true);
         this.currentOffset += 8;
@@ -42,7 +42,7 @@ export class BinaryWriter {
     writeU256(bigIntValue) {
         if (bigIntValue >
             115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
-            throw new Error('Value is too large.');
+            throw new Error('u256 value is too large.');
         }
         this.allocSafe(U256_BYTE_LENGTH);
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
@@ -55,7 +55,7 @@ export class BinaryWriter {
     }
     writeU128(bigIntValue) {
         if (bigIntValue > 340282366920938463463374607431768211455n) {
-            throw new Error('Value is too large.');
+            throw new Error('u128 value is too large.');
         }
         this.allocSafe(U128_BYTE_LENGTH);
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue, U128_BYTE_LENGTH);

package/build/transaction/TransactionFactory.d.ts

@@ -6,6 +6,7 @@ import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import { IChallengeSolutionTransactionParameters, IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
 import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
+import { InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
@@ -38,6 +39,13 @@ export interface BitcoinTransferBase {
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
 }
+export interface InteractionResponse {
+    readonly fundingTransaction: string;
+    readonly interactionTransaction: string;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+    readonly preimage: string;
+}
 export interface ChallengeSolution extends BitcoinTransferBase {
     readonly original: ChallengeSolutionTransaction;
 }
@@ -46,11 +54,12 @@ export interface BitcoinTransferResponse extends BitcoinTransferBase {
 }
 export declare class TransactionFactory {
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters): Promise<[string, string, UTXO[]]>;
-    signInteraction(interactionParameters: IInteractionParameters): Promise<[string, string, UTXO[], string]>;
+    signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
     createChallengeSolution(parameters: IChallengeSolutionTransactionParameters): Promise<ChallengeSolution>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];
+    private detectInteractionOPWallet;
     private _createChallengeSolution;
     private createFundTransaction;
     private writePSBTHeader;

package/build/transaction/TransactionFactory.js

@@ -59,6 +59,13 @@ export class TransactionFactory {
         if (!interactionParameters.utxos[0]) {
             throw new Error('Missing at least one UTXO.');
         }
+        const opWalletInteraction = await this.detectInteractionOPWallet(interactionParameters);
+        if (opWalletInteraction) {
+            return opWalletInteraction;
+        }
+        if (!('signer' in interactionParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
         const preTransaction = new InteractionTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]],
@@ -96,12 +103,13 @@ export class TransactionFactory {
         };
         const finalTransaction = new InteractionTransaction(newParams);
         const outTx = await finalTransaction.signTransaction();
-        return [
-            signedTransaction.tx.toHex(),
-            outTx.toHex(),
-            this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
-            preTransaction.getPreimage().toString('hex'),
-        ];
+        return {
+            fundingTransaction: signedTransaction.tx.toHex(),
+            interactionTransaction: outTx.toHex(),
+            estimatedFees: preTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
+            preimage: preTransaction.getPreimage().toString('hex'),
+        };
     }
     async signDeployment(deploymentParameters) {
         const preTransaction = new DeploymentTransaction(deploymentParameters);
@@ -195,6 +203,17 @@ export class TransactionFactory {
         }
         return utxos;
     }
+    async detectInteractionOPWallet(interactionParameters) {
+        if (typeof window === 'undefined' || !window.opnet || !window.opnet.web3) {
+            return null;
+        }
+        const opnet = window.opnet.web3;
+        const interaction = await opnet.signInteraction(interactionParameters);
+        if (!interaction) {
+            throw new Error('Could not sign interaction transaction.');
+        }
+        return interaction;
+    }
     async _createChallengeSolution(parameters) {
         if (!parameters.to)
             throw new Error('Field "to" not provided.');

package/build/transaction/browser/Web3Provider.d.ts

@@ -1,6 +1,6 @@
 import { IDeploymentParameters, IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { DeploymentResult } from '../TransactionFactory';
+import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer'>;
 export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network'>;
 export interface BroadcastTransactionOptions {
@@ -15,8 +15,8 @@ export interface BroadcastedTransaction {
     readonly identifier: bigint | string;
 }
 export interface Web3Provider {
-    signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[string, string, UTXO[]]>;
-    signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[]]>;
+    signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<InteractionResponse>;
+    signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[], string]>;
     deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.2.4",
+    "version": "1.2.5",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.2.3';
+export const version = '1.2.5';

package/src/buffer/BinaryWriter.ts

@@ -22,14 +22,14 @@ export class BinaryWriter {
     }
 
     public writeU8(value: u8): void {
-        if (value > 255) throw new Error('Value is too large.');
+        if (value > 255) throw new Error('u8 value is too large.');
 
         this.allocSafe(U8_BYTE_LENGTH);
         this.buffer.setUint8(this.currentOffset++, value);
     }
 
     public writeU16(value: u16): void {
-        if (value > 65535) throw new Error('Value is too large.');
+        if (value > 65535) throw new Error('u16 value is too large.');
 
         this.allocSafe(U16_BYTE_LENGTH);
         this.buffer.setUint16(this.currentOffset, value, true);
@@ -37,7 +37,7 @@ export class BinaryWriter {
     }
 
     public writeU32(value: u32, le: boolean = true): void {
-        if (value > 4294967295) throw new Error('Value is too large.');
+        if (value > 4294967295) throw new Error('u32 value is too large.');
 
         this.allocSafe(U32_BYTE_LENGTH);
         this.buffer.setUint32(this.currentOffset, value, le);
@@ -45,7 +45,7 @@ export class BinaryWriter {
     }
 
     public writeU64(value: u64): void {
-        if (value > 18446744073709551615n) throw new Error('Value is too large.');
+        if (value > 18446744073709551615n) throw new Error('u64 value is too large.');
 
         this.allocSafe(U64_BYTE_LENGTH);
         this.buffer.setBigUint64(this.currentOffset, value, true);
@@ -65,7 +65,7 @@ export class BinaryWriter {
             bigIntValue >
             115792089237316195423570985008687907853269984665640564039457584007913129639935n
         ) {
-            throw new Error('Value is too large.');
+            throw new Error('u256 value is too large.');
         }
 
         this.allocSafe(U256_BYTE_LENGTH);
@@ -82,7 +82,7 @@ export class BinaryWriter {
 
     public writeU128(bigIntValue: bigint): void {
         if (bigIntValue > 340282366920938463463374607431768211455n) {
-            throw new Error('Value is too large.');
+            throw new Error('u128 value is too large.');
         }
 
         this.allocSafe(U128_BYTE_LENGTH);

package/src/transaction/TransactionFactory.ts

@@ -19,6 +19,7 @@ import {
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
 import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
+import { InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -60,6 +61,14 @@ export interface BitcoinTransferBase {
     readonly nextUTXOs: UTXO[];
 }
 
+export interface InteractionResponse {
+    readonly fundingTransaction: string;
+    readonly interactionTransaction: string;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+    readonly preimage: string;
+}
+
 export interface ChallengeSolution extends BitcoinTransferBase {
     readonly original: ChallengeSolutionTransaction;
 }
@@ -141,11 +150,11 @@ export class TransactionFactory {
 
     /**
      * @description Generates the required transactions.
-     * @returns {Promise<[string, string]>} - The signed transaction
+     * @returns {Promise<InteractionResponse>} - The signed transaction
      */
     public async signInteraction(
-        interactionParameters: IInteractionParameters,
-    ): Promise<[string, string, UTXO[], string]> {
+        interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner,
+    ): Promise<InteractionResponse> {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
         }
@@ -158,6 +167,16 @@ export class TransactionFactory {
             throw new Error('Missing at least one UTXO.');
         }
 
+        // If OP_WALLET is used...
+        const opWalletInteraction = await this.detectInteractionOPWallet(interactionParameters);
+        if (opWalletInteraction) {
+            return opWalletInteraction;
+        }
+
+        if (!('signer' in interactionParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
+
         const preTransaction: InteractionTransaction = new InteractionTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]], // we simulate one input here.
@@ -212,12 +231,17 @@ export class TransactionFactory {
 
         // We have to regenerate using the new utxo
         const outTx: Transaction = await finalTransaction.signTransaction();
-        return [
-            signedTransaction.tx.toHex(),
-            outTx.toHex(),
-            this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1), // always 1
-            preTransaction.getPreimage().toString('hex'),
-        ];
+        return {
+            fundingTransaction: signedTransaction.tx.toHex(),
+            interactionTransaction: outTx.toHex(),
+            estimatedFees: preTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(
+                signedTransaction.tx,
+                interactionParameters.from,
+                1,
+            ), // always 1
+            preimage: preTransaction.getPreimage().toString('hex'),
+        };
     }
 
     /**
@@ -365,6 +389,22 @@ export class TransactionFactory {
         return utxos;
     }
 
+    private async detectInteractionOPWallet(
+        interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner,
+    ): Promise<InteractionResponse | null> {
+        if (typeof window === 'undefined' || !window.opnet || !window.opnet.web3) {
+            return null;
+        }
+
+        const opnet = window.opnet.web3;
+        const interaction = await opnet.signInteraction(interactionParameters);
+        if (!interaction) {
+            throw new Error('Could not sign interaction transaction.');
+        }
+
+        return interaction;
+    }
+
     private async _createChallengeSolution(
         parameters: IChallengeSolutionTransactionParameters,
     ): Promise<ChallengeSolutionResponse> {

package/src/transaction/browser/Web3Provider.ts

@@ -3,7 +3,7 @@ import {
     IInteractionParameters,
 } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { DeploymentResult } from '../TransactionFactory';
+import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
 
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer'>;
 export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network'>;
@@ -41,11 +41,11 @@ export interface BroadcastedTransaction {
 export interface Web3Provider {
     signInteraction(
         interactionParameters: InteractionParametersWithoutSigner,
-    ): Promise<[string, string, UTXO[]]>;
+    ): Promise<InteractionResponse>;
 
     signAndBroadcastInteraction(
         interactionParameters: InteractionParametersWithoutSigner,
-    ): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[]]>;
+    ): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[], string]>;
 
     deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;