@btc-vision/transaction 1.8.0-rc.9 → 1.8.2

package/documentation/keypair/mnemonic.md

@@ -268,10 +268,10 @@ for (const w of wallets) {
 }
 ```
 
-### deriveMultipleUnisat()
+### deriveMultipleOPWallet()
 
 ```typescript
-deriveMultipleUnisat(
+deriveMultipleOPWallet(
     addressType?: AddressTypes,
     count?: number,
     startIndex?: number,

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.8.0-rc.9",
+    "version": "1.8.2",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -145,30 +145,30 @@
         "prebuild": "npm run check:circular"
     },
     "devDependencies": {
-        "@types/node": "^25.2.3",
+        "@types/node": "^25.5.0",
         "@types/sha.js": "^2.4.4",
-        "@vitest/browser": "^4.0.18",
-        "@vitest/browser-playwright": "^4.0.18",
-        "@vitest/ui": "^4.0.18",
+        "@vitest/browser": "^4.1.0",
+        "@vitest/browser-playwright": "^4.1.0",
+        "@vitest/ui": "^4.1.0",
         "browserify-zlib": "^0.2.0",
         "buffer": "^6.0.3",
-        "eslint": "^10.0.0",
+        "eslint": "^10.0.3",
         "madge": "^8.0.0",
         "playwright": "^1.58.2",
         "prettier": "^3.8.1",
         "process": "^0.11.10",
         "stream-browserify": "^3.0.0",
         "typedoc": "^0.28.17",
-        "typescript-eslint": "^8.56.0",
-        "vite": "^7.3.1",
+        "typescript-eslint": "^8.57.0",
+        "vite": "^8.0.0",
         "vite-plugin-dts": "^4.5.4",
         "vite-plugin-node-polyfills": "^0.25.0",
-        "vitest": "^4.0.18"
+        "vitest": "^4.1.0"
     },
     "dependencies": {
         "@btc-vision/bip32": "^7.1.2",
-        "@btc-vision/bitcoin": "^7.0.0-rc.6",
-        "@btc-vision/bitcoin-rpc": "^1.0.6",
+        "@btc-vision/bitcoin": "^7.0.0",
+        "@btc-vision/bitcoin-rpc": "^1.1.2",
         "@btc-vision/ecpair": "^4.0.5",
         "@btc-vision/logger": "^1.0.8",
         "@eslint/js": "^10.0.1",
@@ -177,8 +177,14 @@
         "bech32": "^2.0.0",
         "bip174": "^3.0.0",
         "bip39": "^3.1.0",
+        "esbuild": "^0.27.4",
         "pako": "^2.1.0",
         "sha.js": "^2.4.12",
         "typescript": "^5.9.3"
+    },
+    "overrides": {
+        "vite-plugin-node-polyfills": {
+            "vite": "$vite"
+        }
     }
 }

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.8.0-rc.9';
+export const version = '1.8.2';

package/src/generators/builders/HashCommitmentGenerator.ts

@@ -35,13 +35,16 @@ export class HashCommitmentGenerator extends Logger {
 
     /** Maximum weight per standard transaction */
     public static readonly MAX_STANDARD_WEIGHT: number = 400000;
+
     /** Minimum satoshis per output (dust limit) */
     public static readonly MIN_OUTPUT_VALUE: bigint = 330n;
+
     /**
      * Bytes per hash commitment in witness script.
      * OP_HASH160 (1) + push (1) + hash (20) + OP_EQUALVERIFY (1) = 23 bytes
      */
     private static readonly BYTES_PER_COMMITMENT: number = 23;
+
     /**
      * Fixed overhead in witness serialization:
      * - Stack item count: 1 byte
@@ -50,6 +53,7 @@ export class HashCommitmentGenerator extends Logger {
      * - Script base (pubkey + checksig): 35 bytes
      */
     private static readonly WITNESS_FIXED_OVERHEAD: number = 1 + 73 + 3 + 35;
+
     /**
      * Per-chunk overhead in witness:
      * - Data: 81 bytes (80 + 1 length prefix)
@@ -58,6 +62,7 @@ export class HashCommitmentGenerator extends Logger {
      */
     private static readonly WITNESS_PER_CHUNK_OVERHEAD: number =
         HashCommitmentGenerator.MAX_CHUNK_SIZE + 1 + HashCommitmentGenerator.BYTES_PER_COMMITMENT;
+
     /**
      * Maximum data chunks per P2WSH output.
      * Limited by total witness size: (1650 - 112) / 104 = 14 chunks
@@ -67,6 +72,7 @@ export class HashCommitmentGenerator extends Logger {
             HashCommitmentGenerator.WITNESS_FIXED_OVERHEAD) /
             HashCommitmentGenerator.WITNESS_PER_CHUNK_OVERHEAD,
     );
+
     /** Base weight per input (non-witness): 41 bytes * 4 = 164 */
     private static readonly INPUT_BASE_WEIGHT: number = 164;
 
@@ -82,7 +88,9 @@ export class HashCommitmentGenerator extends Logger {
     public static readonly WEIGHT_PER_INPUT: number =
         HashCommitmentGenerator.INPUT_BASE_WEIGHT +
         HashCommitmentGenerator.INPUT_WITNESS_WEIGHT_MAX;
+
     public override readonly logColor: string = '#4a90d9';
+
     private readonly publicKey: Uint8Array;
     private readonly network: Network;
 

package/src/keypair/MessageSigner.ts

@@ -2,6 +2,7 @@ import {
     type MessageHash,
     type PublicKey,
     type SchnorrSignature,
+    type Signature,
     type UniversalSigner,
 } from '@btc-vision/ecpair';
 import { backend } from '../ecc/backend.js';
@@ -11,6 +12,7 @@ import { EcKeyPair } from './EcKeyPair.js';
 import { MLDSASecurityLevel, type QuantumBIP32Interface } from '@btc-vision/bip32';
 import { isOPWallet, type OPWallet } from '../transaction/browser/types/OPWallet.js';
 import type { MLDSASignature } from '../transaction/interfaces/IWeb3ProviderTypes.js';
+import { SignatureType } from '../transaction/browser/types/Unisat.js';
 
 export interface SignedMessage {
     readonly signature: Uint8Array;
@@ -47,7 +49,38 @@ class MessageSignerBase {
         const hashedMessage = this.sha256(messageBuffer);
         const messageHex = toHex(hashedMessage);
 
-        const signatureHex = await wallet.web3.signSchnorr(messageHex);
+        const signatureHex = await wallet.signData(
+            messageHex,
+            SignatureType.schnorr,
+            typeof message === 'string' ? message : undefined,
+        );
+
+        return {
+            signature: fromHex(signatureHex),
+            message: hashedMessage,
+        };
+    }
+
+    public async trySignECDSAWithOPWallet(
+        message: Uint8Array | string,
+    ): Promise<SignedMessage | null> {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+
+        const messageBuffer =
+            typeof message === 'string' ? new TextEncoder().encode(message) : message;
+
+        const hashedMessage = this.sha256(messageBuffer);
+        const messageHex = toHex(hashedMessage);
+
+        const signatureHex = await wallet.signData(
+            messageHex,
+            SignatureType.ecdsa,
+            typeof message === 'string' ? message : undefined,
+        );
+
         return {
             signature: fromHex(signatureHex),
             message: hashedMessage,
@@ -68,7 +101,11 @@ class MessageSignerBase {
         const hashedMessage = this.sha256(messageBuffer);
         const messageHex = toHex(hashedMessage);
 
-        const result: MLDSASignature = await wallet.web3.signMLDSAMessage(messageHex);
+        const result: MLDSASignature = await wallet.web3.signMLDSAMessage(
+            messageHex,
+            typeof message === 'string' ? message : undefined,
+        );
+
         return {
             signature: fromHex(result.signature),
             message: hashedMessage,
@@ -93,6 +130,22 @@ class MessageSignerBase {
         return this.signMessage(keypair, message);
     }
 
+    public async signMessageECDSAAuto(
+        message: Uint8Array | string,
+        keypair?: UniversalSigner,
+    ): Promise<SignedMessage> {
+        if (!keypair) {
+            const walletResult = await this.trySignECDSAWithOPWallet(message);
+            if (walletResult) {
+                return walletResult;
+            }
+
+            throw new Error('No keypair provided and OP_WALLET is not available.');
+        }
+
+        return this.signECDSA(keypair, message);
+    }
+
     public async tweakAndSignMessageAuto(
         message: Uint8Array | string,
         keypair?: UniversalSigner,
@@ -194,6 +247,52 @@ class MessageSignerBase {
         };
     }
 
+    public signECDSA(keypair: UniversalSigner, message: Uint8Array | string): SignedMessage {
+        if (typeof message === 'string') {
+            message = new TextEncoder().encode(message);
+        }
+
+        if (!keypair.privateKey) {
+            throw new Error('Private key not found in keypair.');
+        }
+
+        const hashedMessage = this.sha256(message);
+
+        if (!backend.sign) {
+            throw new Error('backend.signSchnorr is not available.');
+        }
+
+        return {
+            signature: backend.sign(hashedMessage as MessageHash, keypair.privateKey),
+            message: hashedMessage,
+        };
+    }
+
+    public verifyECDSASignature(
+        publicKey: Uint8Array | PublicKey,
+        message: Uint8Array | string,
+        signature: Uint8Array | Signature,
+    ): boolean {
+        if (typeof message === 'string') {
+            message = new TextEncoder().encode(message);
+        }
+
+        if (signature.length !== 64) {
+            throw new Error('Invalid signature length.');
+        }
+
+        const hashedMessage = this.sha256(message);
+        if (!backend.verify) {
+            throw new Error('backend.verifySchnorr is not available.');
+        }
+
+        return backend.verify(
+            hashedMessage as MessageHash,
+            publicKey as PublicKey,
+            signature as Signature,
+        );
+    }
+
     public verifySignature(
         publicKey: Uint8Array,
         message: Uint8Array | string,
@@ -208,7 +307,6 @@ class MessageSignerBase {
         }
 
         const hashedMessage = this.sha256(message);
-
         if (!backend.verifySchnorr) {
             throw new Error('backend.verifySchnorr is not available.');
         }

package/src/mnemonic/Mnemonic.ts

@@ -187,7 +187,7 @@ export class Mnemonic implements Disposable {
         );
     }
 
-    public deriveMultipleUnisat(
+    public deriveMultipleOPWallet(
         addressType: AddressTypes = AddressTypes.P2TR,
         count: number = 5,
         startIndex: number = 0,

package/src/transaction/TransactionFactory.ts

@@ -23,6 +23,7 @@ import type {
     ICancelTransactionParametersWithoutSigner,
     ICustomTransactionWithoutSigner,
     IDeploymentParametersWithoutSigner,
+    IFundingTransactionParametersWithoutSigner,
     InteractionParametersWithoutSigner,
 } from './interfaces/IWeb3ProviderTypes.js';
 import type { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
@@ -35,6 +36,7 @@ import { CancelTransaction } from './builders/CancelTransaction.js';
 import { ConsolidatedInteractionTransaction } from './builders/ConsolidatedInteractionTransaction.js';
 import type { IConsolidatedInteractionParameters } from './interfaces/IConsolidatedTransactionParameters.js';
 import type {
+    BitcoinTransferBase,
     CancelledTransaction,
     DeploymentResult,
     InteractionResponse,
@@ -50,12 +52,7 @@ export interface FundingTransactionResponse {
     readonly inputUtxos: UTXO[];
 }
 
-export interface BitcoinTransferBase {
-    readonly tx: string;
-    readonly estimatedFees: bigint;
-    readonly nextUTXOs: UTXO[];
-    readonly inputUtxos: UTXO[];
-}
+export type { BitcoinTransferBase } from './interfaces/ITransactionResponses.js';
 
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;
@@ -348,7 +345,7 @@ export class TransactionFactory {
                 1,
             ),
             challenge: challenge.toRaw(),
-            fundingUTXOs: fundingUTXO,
+            fundingUTXOs: [...fundingUTXO, ...inputs],
             fundingInputUtxos: interactionParameters.utxos,
             compiledTargetScript: toHex(interactionTx.exportCompiledTargetScript()),
         };
@@ -529,19 +526,31 @@ export class TransactionFactory {
     /**
      * @description Creates a funding transaction.
      * @param {IFundingTransactionParameters} parameters - The funding transaction parameters
-     * @returns {Promise<BitcoinTransferResponse>} - The signed transaction
+     * @returns {Promise<BitcoinTransferBase>} - The signed transaction
      */
     public async createBTCTransfer(
-        parameters: IFundingTransactionParameters,
-    ): Promise<BitcoinTransferResponse> {
+        parameters: IFundingTransactionParameters | IFundingTransactionParametersWithoutSigner,
+    ): Promise<BitcoinTransferBase> {
+        if (!parameters.to) {
+            throw new Error('Field "to" not provided.');
+        }
+
         if (!parameters.from) {
             throw new Error('Field "from" not provided.');
         }
 
+        const opWalletInteraction = await this.detectFundingOPWallet(parameters);
+        if (opWalletInteraction) {
+            return opWalletInteraction;
+        }
+
+        if (!('signer' in parameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
+
         const resp = await this.createFundTransaction(parameters);
         return {
             estimatedFees: resp.estimatedFees,
-            original: resp.original,
             tx: resp.tx.toHex(),
             nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
             inputUtxos: parameters.utxos,
@@ -600,6 +609,41 @@ export class TransactionFactory {
         });
     }
 
+    /**
+     * Detect and use OP_WALLET for funding transactions if available.
+     *
+     * @param {IFundingTransactionParameters | IFundingTransactionParametersWithoutSigner} fundingParams - The funding transaction parameters
+     * @return {Promise<BitcoinTransferBase | null>} - The funding transaction response or null if OP_WALLET not available
+     */
+    private async detectFundingOPWallet(
+        fundingParams: IFundingTransactionParameters | IFundingTransactionParametersWithoutSigner,
+    ): Promise<BitcoinTransferBase | null> {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+
+        const _window = window as WindowWithWallets;
+        if (!_window || !_window.opnet || !_window.opnet.web3) {
+            return null;
+        }
+
+        const opnet = _window.opnet.web3;
+        const result = await opnet.sendBitcoin({
+            ...fundingParams,
+            // @ts-expect-error signer is stripped by the wallet
+            signer: undefined,
+        });
+
+        if (!result) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        return {
+            ...result,
+            inputUtxos: result.inputUtxos ?? fundingParams.utxos,
+        };
+    }
+
     /**
      * Detect and use OP_WALLET for cancel transactions if available.
      * @param {ICancelTransactionParameters | ICancelTransactionParametersWithoutSigner} interactionParameters - The cancel parameters

package/src/transaction/browser/Web3Provider.ts

@@ -1,5 +1,6 @@
 import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import type {
+    BitcoinTransferBase,
     CancelledTransaction,
     DeploymentResult,
     InteractionResponse,
@@ -10,11 +11,22 @@ import type {
     ICancelTransactionParametersWithoutSigner,
     ICustomTransactionWithoutSigner,
     IDeploymentParametersWithoutSigner,
+    IFundingTransactionParametersWithoutSigner,
     InteractionParametersWithoutSigner,
     MLDSASignature,
 } from '../interfaces/IWeb3ProviderTypes.js';
 
 export interface Web3Provider {
+    /**
+     * Build, sign, and broadcast a BTC funding transaction.
+     * The wallet provides signer, network, and MLDSA internally.
+     * The confirmation flow is handled by TxOpnetConfirmScreen.
+     *
+     * @param params - Funding transaction parameters (amount, to, feeRate, etc.)
+     * @returns The BitcoinTransferBase with tx hex, fees, and UTXOs
+     */
+    sendBitcoin(params: IFundingTransactionParametersWithoutSigner): Promise<BitcoinTransferBase>;
+
     signInteraction(
         interactionParameters: InteractionParametersWithoutSigner,
     ): Promise<InteractionResponse>;
@@ -33,6 +45,13 @@ export interface Web3Provider {
 
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
 
+    /**
+     * Sign a PSBT (Partially Signed Bitcoin Transaction).
+     *
+     * NOT IMPLEMENTED YET — will throw an error if called.
+     */
+    signPsbt(psbtHex: string, options?: object): Promise<string>;
+
     /**
      * Sign a message using Schnorr signature
      * @param message - Hexadecimal string message to sign
@@ -53,10 +72,11 @@ export interface Web3Provider {
      * Sign a message using ML-DSA signature
      *
      * @param message - The message to sign as a hexadecimal string
+     * @param [originalMessage] - (Optional) The original message before hashing, used for ML-DSA signature verification. If not provided, the message will be hashed internally.
      * @returns The ML-DSA signature
      * @throws {Error} If signing fails or wallet is not connected
      */
-    signMLDSAMessage(message: string): Promise<MLDSASignature>;
+    signMLDSAMessage(message: string, originalMessage?: string): Promise<MLDSASignature>;
 
     /**
      * Verify an ML-DSA signature

package/src/transaction/browser/types/Unisat.ts

@@ -54,12 +54,6 @@ export interface Unisat {
     disconnect: () => Promise<void>;
     connect: () => Promise<void>;
 
-    sendBitcoin(
-        toAddress: string,
-        satoshis: number,
-        options: { feeRate: number; memo?: string; memos?: string[] },
-    ): Promise<string>;
-
     requestAccounts(): Promise<string[]>;
 
     getNetwork(): Promise<WalletNetworks>;
@@ -70,13 +64,15 @@ export interface Unisat {
 
     switchNetwork(network: WalletNetworks): Promise<void>;
 
+    switchChain(network: UnisatChainType): Promise<void>;
+
     getPublicKey(): Promise<string>;
 
     getBalance(): Promise<Balance>;
 
     signMessage(message: string | Uint8Array, type?: MessageType): Promise<string>;
 
-    signData(hex: string, type?: SignatureType): Promise<string>;
+    signData(hex: string, type?: SignatureType, originalMessage?: string): Promise<string>;
 
     pushTx(options: { rawtx: string }): Promise<string>;
 

package/src/transaction/builders/DeploymentTransaction.ts

@@ -38,7 +38,7 @@ import { type Feature, FeaturePriority, Features } from '../../generators/Featur
 import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
-    public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
+    public static readonly MAXIMUM_CONTRACT_SIZE = 1536 * 1024;
 
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
 

package/src/transaction/builders/FundingTransaction.ts

@@ -34,29 +34,43 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         // When autoAdjustAmount is enabled and the amount would leave no room for fees,
         // estimate the fee first and reduce the output amount accordingly.
         if (this.autoAdjustAmount && this.amount >= this.totalInputAmount) {
-            // Add a temporary output at full amount to get an accurate fee estimate
-            if (this.isPubKeyDestination) {
-                const toHexClean = this.to.startsWith('0x') ? this.to.slice(2) : this.to;
-                const pubKeyScript: Script = script.compile([
-                    fromHex(toHexClean),
-                    opcodes.OP_CHECKSIG,
-                ]);
+            // Add temporary outputs matching the ACTUAL final transaction shape
+            // so the fee estimate accounts for the real vsize.
+            const numOutputs = this.splitInputsInto > 1 ? this.splitInputsInto : 1;
+            const perOutputAmount = this.amount / BigInt(numOutputs);
+
+            for (let i = 0; i < numOutputs; i++) {
+                if (this.isPubKeyDestination) {
+                    const toHexClean = this.to.startsWith('0x') ? this.to.slice(2) : this.to;
+                    const pubKeyScript: Script = script.compile([
+                        fromHex(toHexClean),
+                        opcodes.OP_CHECKSIG,
+                    ]);
+
+                    this.addOutput({
+                        value: toSatoshi(perOutputAmount),
+                        script: pubKeyScript,
+                    });
+                } else {
+                    this.addOutput({
+                        value: toSatoshi(perOutputAmount),
+                        address: this.to,
+                    });
+                }
+            }
 
-                this.addOutput({
-                    value: toSatoshi(this.amount),
-                    script: pubKeyScript,
-                });
-            } else {
-                this.addOutput({
-                    value: toSatoshi(this.amount),
-                    address: this.to,
-                });
+            // If a note is present, add a temporary OP_RETURN since it affects vsize.
+            if (this.note) {
+                this.addOPReturn(this.note);
             }
 
             const estimatedFee = await this.estimateTransactionFees();
 
-            // Remove the temporary output
-            this.outputs.pop();
+            // Remove all temporary outputs.
+            const tempCount = numOutputs + (this.note ? 1 : 0);
+            for (let i = 0; i < tempCount; i++) {
+                this.outputs.pop();
+            }
 
             const adjustedAmount = this.totalInputAmount - estimatedFee;
             if (adjustedAmount < TransactionBuilder.MINIMUM_DUST) {

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -33,7 +33,7 @@ import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export abstract class SharedInteractionTransaction<
     T extends TransactionType,
 > extends TransactionBuilder<T> {
-    public static readonly MAXIMUM_CALLDATA_SIZE = 1024 * 1024; // 1MB
+    public static readonly MAXIMUM_CALLDATA_SIZE = 380 * 1024; // 1MB
 
     /**
      * Random salt for the interaction

package/src/transaction/interfaces/ITransactionResponses.ts

@@ -1,6 +1,13 @@
 import type { RawChallenge } from '../../epoch/interfaces/IChallengeSolution.js';
 import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 
+export interface BitcoinTransferBase {
+    readonly tx: string;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+    readonly inputUtxos: UTXO[];
+}
+
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;

package/src/transaction/interfaces/IWeb3ProviderTypes.ts

@@ -1,4 +1,8 @@
-import type { IDeploymentParameters, IInteractionParameters } from './ITransactionParameters.js';
+import type {
+    IDeploymentParameters,
+    IFundingTransactionParameters,
+    IInteractionParameters,
+} from './ITransactionParameters.js';
 import type { ICustomTransactionParameters } from './ICustomTransactionParameters.js';
 import type { ICancelTransactionParameters } from './ICancelTransactionParameters.js';
 import { MLDSASecurityLevel } from '@btc-vision/bip32';
@@ -23,6 +27,11 @@ export type ICancelTransactionParametersWithoutSigner = Omit<
     'signer' | 'challenge' | 'network' | 'mldsaSigner'
 >;
 
+export type IFundingTransactionParametersWithoutSigner = Omit<
+    IFundingTransactionParameters,
+    'signer' | 'network' | 'mldsaSigner' | 'gasSatFee'
+>;
+
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;

package/test/derivePath.test.ts

@@ -420,7 +420,7 @@ describe('Mnemonic.deriveOPWallet', () => {
         });
     });
 
-    describe('deriveMultipleUnisat', () => {
+    describe('deriveMultipleOPWallet', () => {
         it('should derive multiple wallets', () => {
             const mnemonic = new Mnemonic(
                 testMnemonic,
@@ -429,7 +429,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 5);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallets.length).toBe(5);
             expect((wallets[0] as Wallet).p2tr).toBeDefined();
@@ -444,7 +444,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 3);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 3);
 
             const addresses = wallets.map((w) => w.p2tr);
             const uniqueAddresses = new Set(addresses);
@@ -460,7 +460,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 2, 5);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 2, 5);
             const wallet5 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect((wallets[0] as Wallet).p2tr).toBe(wallet5.p2tr);