@btc-vision/transaction 1.8.0-beta.1 → 1.8.0-beta.4

package/src/mnemonic/Mnemonic.ts

@@ -1,91 +1,36 @@
 import * as bip39 from 'bip39';
 import {
     BIP32Factory,
-    BIP32Interface,
+    type BIP32Interface,
     MLDSASecurityLevel,
     QuantumBIP32Factory,
-    QuantumBIP32Interface,
+    type QuantumBIP32Interface,
 } from '@btc-vision/bip32';
-import * as ecc from '@bitcoinerlab/secp256k1';
-import { initEccLib, Network, networks } from '@btc-vision/bitcoin';
+import { initEccLib, type Network, networks, toHex } from '@btc-vision/bitcoin';
+import { backend, eccLib } from '../ecc/backend.js';
 import { Wallet } from '../keypair/Wallet.js';
 import { MnemonicStrength } from './MnemonicStrength.js';
 import { BIPStandard, buildBIPPath } from './BIPStandard.js';
 import { AddressTypes } from '../keypair/AddressVerificator.js';
 
-initEccLib(ecc);
+initEccLib(eccLib);
 
-const bip32 = BIP32Factory(ecc);
+const bip32 = BIP32Factory(backend);
 
 export { BIPStandard, getBIPDescription } from './BIPStandard.js';
 
 /**
  * Mnemonic class for managing BIP39 mnemonic phrases with BIP360 quantum support
- *
- * This class provides methods to generate, validate, and derive wallets from mnemonic phrases.
- * It supports both classical Bitcoin derivation paths (BIP44, BIP84, etc.) and quantum-resistant
- * ML-DSA keys via BIP360.
- *
- * @example
- * ```typescript
- * // Generate a new mnemonic
- * const mnemonic = Mnemonic.generate();
- *
- * // Derive a wallet at index 0
- * const wallet = mnemonic.derive(0);
- *
- * // Derive multiple wallets
- * const wallets = mnemonic.deriveMultiple(5);
- *
- * // Load from existing mnemonic
- * const existingMnemonic = new Mnemonic('your twelve word mnemonic phrase here...');
- * ```
  */
-export class Mnemonic {
-    /**
-     * The BIP39 mnemonic phrase
-     */
+export class Mnemonic implements Disposable {
     private readonly _phrase: string;
-
-    /**
-     * Optional BIP39 passphrase for additional security
-     */
     private readonly _passphrase: string;
-
-    /**
-     * The network to use for derivation
-     */
     private readonly _network: Network;
-
-    /**
-     * The ML-DSA security level for quantum keys
-     */
     private readonly _securityLevel: MLDSASecurityLevel;
-
-    /**
-     * The seed derived from the mnemonic
-     */
-    private readonly _seed: Buffer;
-
-    /**
-     * The classical BIP32 root for Bitcoin keys
-     */
+    private readonly _seed: Uint8Array;
     private readonly _classicalRoot: BIP32Interface;
-
-    /**
-     * The quantum BIP32 root for ML-DSA keys
-     */
     private readonly _quantumRoot: QuantumBIP32Interface;
 
-    /**
-     * Create a new Mnemonic instance from an existing phrase
-     *
-     * @param phrase - The BIP39 mnemonic phrase (12, 15, 18, 21, or 24 words)
-     * @param passphrase - Optional BIP39 passphrase for additional security (default: '')
-     * @param network - The Bitcoin network to use (default: bitcoin mainnet)
-     * @param securityLevel - The ML-DSA security level for quantum keys (default: LEVEL2/44)
-     * @throws {Error} If the mnemonic phrase is invalid
-     */
     constructor(
         phrase: string,
         passphrase: string = '',
@@ -115,63 +60,42 @@ export class Mnemonic {
         );
     }
 
-    /**
-     * Get the mnemonic phrase
-     *
-     * @warning This phrase is highly sensitive and can be used to derive all keys in the wallet.
-     * Handle with extreme care, never log or transmit insecurely, and store only in secure environments.
-     *
-     * @returns The BIP39 mnemonic phrase
-     */
     public get phrase(): string {
         return this._phrase;
     }
 
-    /**
-     * Get the network
-     */
     public get network(): Network {
         return this._network;
     }
 
-    /**
-     * Get the ML-DSA security level
-     */
     public get securityLevel(): MLDSASecurityLevel {
         return this._securityLevel;
     }
 
-    /**
-     * Get the seed derived from the mnemonic phrase
-     *
-     * @warning This seed is highly sensitive and can be used to derive all keys in the wallet.
-     * Handle with extreme care, never log or transmit insecurely, and store only in secure environments.
-     *
-     * @returns A copy of the seed buffer to prevent external modification
-     */
-    public get seed(): Buffer {
-        return Buffer.from(this._seed);
+    public get seed(): Uint8Array {
+        return new Uint8Array(this._seed);
     }
 
     /**
-     * Generate a new mnemonic phrase
+     * Best-effort zeroing of secret material held by this mnemonic.
      *
-     * @param strength - The entropy strength in bits (default: 256 for 24 words)
-     * @returns A new random mnemonic phrase
+     * Zeros the seed buffer and root private keys in-place.
+     * The mnemonic phrase and passphrase are JS strings and cannot be zeroed.
      */
+    public zeroize(): void {
+        this._seed.fill(0);
+        this._classicalRoot.privateKey?.fill(0);
+        this._quantumRoot.privateKey?.fill(0);
+    }
+
+    public [Symbol.dispose](): void {
+        this.zeroize();
+    }
+
     public static generatePhrase(strength: MnemonicStrength = MnemonicStrength.MAXIMUM): string {
         return bip39.generateMnemonic(strength);
     }
 
-    /**
-     * Generate a new Mnemonic instance with a random phrase
-     *
-     * @param strength - The entropy strength in bits (default: 256 for 24 words)
-     * @param passphrase - Optional BIP39 passphrase for additional security (default: '')
-     * @param network - The Bitcoin network to use (default: bitcoin mainnet)
-     * @param securityLevel - The ML-DSA security level for quantum keys (default: LEVEL2/44)
-     * @returns A new Mnemonic instance
-     */
     public static generate(
         strength: MnemonicStrength = MnemonicStrength.MAXIMUM,
         passphrase: string = '',
@@ -182,47 +106,16 @@ export class Mnemonic {
         return new Mnemonic(phrase, passphrase, network, securityLevel);
     }
 
-    /**
-     * Validate a mnemonic phrase
-     *
-     * @param phrase - The mnemonic phrase to validate
-     * @returns True if the phrase is valid, false otherwise
-     */
     public static validate(phrase: string): boolean {
         return bip39.validateMnemonic(phrase);
     }
 
-    /**
-     * Derive a wallet at a specific index using BIP360 (quantum) and configurable BIP standard (classical) paths
-     *
-     * This method derives both classical ECDSA/Schnorr keys and quantum-resistant ML-DSA keys
-     * for the wallet, providing hybrid post-quantum security.
-     *
-     * @param index - The address index to derive (default: 0)
-     * @param account - The account index (default: 0)
-     * @param isChange - Whether this is a change address (default: false)
-     * @param bipStandard - The BIP standard to use for classical derivation (default: BIP84)
-     * @returns A Wallet instance with both classical and quantum keys
-     *
-     * @example
-     * ```typescript
-     * // Default: BIP84 (Native SegWit)
-     * const wallet1 = mnemonic.derive(0);
-     *
-     * // BIP44 (Compatible with Unisat)
-     * const wallet2 = mnemonic.derive(0, 0, false, BIPStandard.BIP44);
-     *
-     * // BIP86 (Taproot)
-     * const wallet3 = mnemonic.derive(0, 0, false, BIPStandard.BIP86);
-     * ```
-     */
     public derive(
         index: number = 0,
         account: number = 0,
         isChange: boolean = false,
         bipStandard: BIPStandard = BIPStandard.BIP84,
     ): Wallet {
-        // Derive classical key using specified BIP standard
         const classicalPath = this.buildClassicalPath(account, index, isChange, bipStandard);
         const classicalChild = this._classicalRoot.derivePath(classicalPath);
 
@@ -230,7 +123,6 @@ export class Mnemonic {
             throw new Error(`Failed to derive classical private key at index ${index}`);
         }
 
-        // Derive quantum key using BIP360
         const quantumPath = this.buildQuantumPath(account, index, isChange);
         const quantumChild = this._quantumRoot.derivePath(quantumPath);
 
@@ -238,38 +130,21 @@ export class Mnemonic {
             throw new Error(`Failed to derive quantum private key at index ${index}`);
         }
 
-        // Create a wallet with both keys
         return new Wallet(
-            Buffer.from(classicalChild.privateKey).toString('hex'),
-            Buffer.from(quantumChild.privateKey).toString('hex'),
+            toHex(new Uint8Array(classicalChild.privateKey)),
+            toHex(new Uint8Array(quantumChild.privateKey)),
             this._network,
             this._securityLevel,
-            Buffer.from(this._quantumRoot.chainCode),
+            new Uint8Array(this._quantumRoot.chainCode),
         );
     }
 
-    /**
-     * Derive a Unisat-compatible wallet
-     *
-     * Unisat uses different derivation paths based on address type:
-     * - Legacy (P2PKH): m/44'/coinType'/account'/change/index
-     * - Nested SegWit (P2SH-P2WPKH): m/49'/coinType'/account'/change/index
-     * - Native SegWit (P2WPKH): m/84'/coinType'/account'/change/index
-     * - Taproot (P2TR): m/86'/coinType'/account'/change/index
-     *
-     * @param addressType - The address type to generate
-     * @param index - The address index (default: 0)
-     * @param account - The account index (default: 0)
-     * @param isChange - Whether this is a change address (default: false)
-     * @returns A Wallet instance with both classical and quantum keys
-     */
     public deriveOPWallet(
         addressType: AddressTypes = AddressTypes.P2TR,
         index: number = 0,
         account: number = 0,
         isChange: boolean = false,
     ): Wallet {
-        // Determine BIP purpose based on address type
         let purpose: number;
         switch (addressType) {
             case AddressTypes.P2PKH:
@@ -288,19 +163,16 @@ export class Mnemonic {
                 throw new Error(`Unsupported address type: ${addressType}`);
         }
 
-        // Build classical derivation path for Unisat
         const coinType = this.getCoinType();
         const change = isChange ? 1 : 0;
         const classicalPath = `m/${purpose}'/0'/${account}'/${change}/${index}`;
 
-        // Derive classical key
         const classicalChild = this._classicalRoot.derivePath(classicalPath);
 
         if (!classicalChild.privateKey) {
             throw new Error(`Failed to derive classical private key at path ${classicalPath}`);
         }
 
-        // Derive quantum key using BIP360
         const quantumPath = `m/360'/${coinType}'/${account}'/${change}/${index}`;
         const quantumChild = this._quantumRoot.derivePath(quantumPath);
 
@@ -308,26 +180,15 @@ export class Mnemonic {
             throw new Error(`Failed to derive quantum private key at path ${quantumPath}`);
         }
 
-        // Create wallet with both classical and quantum keys
         return new Wallet(
-            Buffer.from(classicalChild.privateKey).toString('hex'),
-            Buffer.from(quantumChild.privateKey).toString('hex'),
+            toHex(new Uint8Array(classicalChild.privateKey)),
+            toHex(new Uint8Array(quantumChild.privateKey)),
             this._network,
             this._securityLevel,
-            Buffer.from(this._quantumRoot.chainCode),
+            new Uint8Array(this._quantumRoot.chainCode),
         );
     }
 
-    /**
-     * Derive multiple Unisat-compatible wallets
-     *
-     * @param addressType - The address type to generate
-     * @param count - Number of wallets to derive
-     * @param startIndex - Starting index (default: 0)
-     * @param account - The account index (default: 0)
-     * @param isChange - Whether these are change addresses (default: false)
-     * @returns Array of Wallet instances
-     */
     public deriveMultipleUnisat(
         addressType: AddressTypes = AddressTypes.P2TR,
         count: number = 5,
@@ -344,16 +205,6 @@ export class Mnemonic {
         return wallets;
     }
 
-    /**
-     * Derive multiple wallets with sequential indices
-     *
-     * @param count - The number of wallets to derive
-     * @param startIndex - The starting address index (default: 0)
-     * @param account - The account index (default: 0)
-     * @param isChange - Whether these are change addresses (default: false)
-     * @param bipStandard - The BIP standard to use for classical derivation (default: BIP84)
-     * @returns An array of Wallet instances
-     */
     public deriveMultiple(
         count: number,
         startIndex: number = 0,
@@ -370,13 +221,6 @@ export class Mnemonic {
         return wallets;
     }
 
-    /**
-     * Derive a wallet using a custom derivation path
-     *
-     * @param classicalPath - The BIP32 path for classical keys (e.g., "m/84'/0'/0'/0/0")
-     * @param quantumPath - The BIP360 path for quantum keys (e.g., "m/360'/0'/0'/0/0")
-     * @returns A Wallet instance
-     */
     public deriveCustomPath(classicalPath: string, quantumPath: string): Wallet {
         const classicalChild = this._classicalRoot.derivePath(classicalPath);
         const quantumChild = this._quantumRoot.derivePath(quantumPath);
@@ -389,43 +233,23 @@ export class Mnemonic {
             throw new Error(`Failed to derive quantum private key at path ${quantumPath}`);
         }
 
-        // Create wallet with both classical and ML-DSA private keys
         return new Wallet(
-            Buffer.from(classicalChild.privateKey).toString('hex'),
-            Buffer.from(quantumChild.privateKey).toString('hex'),
+            toHex(new Uint8Array(classicalChild.privateKey)),
+            toHex(new Uint8Array(quantumChild.privateKey)),
             this._network,
             this._securityLevel,
-            Buffer.from(this._quantumRoot.chainCode),
+            new Uint8Array(this._quantumRoot.chainCode),
         );
     }
 
-    /**
-     * Get the classical BIP32 root
-     *
-     * @returns The classical BIP32Interface for manual derivation
-     */
     public getClassicalRoot(): BIP32Interface {
         return this._classicalRoot;
     }
 
-    /**
-     * Get the quantum BIP32 root
-     *
-     * @returns The quantum BIP32Interface for manual derivation
-     */
     public getQuantumRoot(): QuantumBIP32Interface {
         return this._quantumRoot;
     }
 
-    /**
-     * Build a classical derivation path using specified BIP standard
-     *
-     * @param account - The account index
-     * @param index - The address index
-     * @param isChange - Whether this is a change address
-     * @param bipStandard - The BIP standard to use (default: BIP84)
-     * @returns The derivation path string
-     */
     private buildClassicalPath(
         account: number,
         index: number,
@@ -437,25 +261,12 @@ export class Mnemonic {
         return buildBIPPath(bipStandard, coinType, account, change, index);
     }
 
-    /**
-     * Build a quantum derivation path (BIP360)
-     *
-     * @param account - The account index
-     * @param index - The address index
-     * @param isChange - Whether this is a change address
-     * @returns The derivation path string
-     */
     private buildQuantumPath(account: number, index: number, isChange: boolean): string {
         const coinType = this.getCoinType();
         const change = isChange ? 1 : 0;
         return `m/360'/${coinType}'/${account}'/${change}/${index}`;
     }
 
-    /**
-     * Get the coin type based on the network
-     *
-     * @returns The coin type (0 for mainnet, 1 for testnet/regtest)
-     */
     private getCoinType(): number {
         if (
             this._network.bech32 === networks.testnet.bech32 ||

package/src/opnet.ts

@@ -1,5 +1,8 @@
-import { Unisat } from './transaction/browser/types/Unisat.js';
-import { OPWallet } from './transaction/browser/types/OPWallet.js';
+/** Polyfill Symbol.dispose / Symbol.asyncDispose for Safari & Android WebView */
+import './polyfill/disposable.js';
+
+import type { Unisat } from './transaction/browser/types/Unisat.js';
+import type { OPWallet } from './transaction/browser/types/OPWallet.js';
 
 export { version } from './_version.js';
 
@@ -40,10 +43,10 @@ export * from './mnemonic/BIPStandard.js';
 /** Quantum (ML-DSA) */
 export {
     MLDSASecurityLevel,
-    MLDSAKeyPair,
-    QuantumBIP32Interface,
-    QuantumBIP32API,
-    QuantumSigner,
+    type MLDSAKeyPair,
+    type QuantumBIP32Interface,
+    type QuantumBIP32API,
+    type QuantumSigner,
     QuantumBIP32Factory,
     QuantumDerivationPath,
 } from '@btc-vision/bip32';
@@ -59,6 +62,9 @@ export * from './signer/TweakedSigner.js';
 export * from './signer/IRotationSigner.js';
 export * from './signer/AddressRotation.js';
 
+/** Parallel Signing */
+export * from './signer/ParallelSignerAdapter.js';
+
 /** Transaction */
 export * from './transaction/enums/TransactionType.js';
 export * from './transaction/interfaces/ITransactionParameters.js';

package/src/p2wda/P2WDADetector.ts

@@ -1,44 +1,31 @@
-import { Buffer } from 'buffer';
-import { Network, opcodes, payments, script } from '@btc-vision/bitcoin';
-import { UTXO } from '../utxo/interfaces/IUTXO.js';
-import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+import { fromHex, type Network, opcodes, payments, script } from '@btc-vision/bitcoin';
+import type { UTXO } from '../utxo/interfaces/IUTXO.js';
+import type { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 
 /**
  * P2WDA Detection and Validation Utilities
- *
- * This class provides methods to detect and validate P2WDA (Pay-to-Witness-Data-Authentication) addresses
- * and UTXOs. P2WDA addresses have a specific witness script pattern that allows for efficient data storage.
  */
 export class P2WDADetector {
     /**
      * Check if a UTXO is a P2WDA output by examining its script structure
-     *
-     * @param utxo The UTXO to check
-     * @returns true if this is a P2WDA UTXO
      */
     public static isP2WDAUTXO(utxo: UTXO): boolean {
-        // P2WDA outputs are P2WSH outputs with a specific witness script pattern
         if (!utxo.witnessScript) {
             return false;
         }
 
-        const witnessScript = Buffer.isBuffer(utxo.witnessScript)
-            ? utxo.witnessScript
-            : Buffer.from(utxo.witnessScript, 'hex');
+        const witnessScript =
+            utxo.witnessScript instanceof Uint8Array
+                ? utxo.witnessScript
+                : fromHex(utxo.witnessScript);
 
         return this.isP2WDAWitnessScript(witnessScript);
     }
 
     /**
      * Check if a witness script follows the P2WDA pattern
-     *
-     * P2WDA witness script pattern: (OP_2DROP * 5) <pubkey> OP_CHECKSIG
-     * This allows for up to 10 witness data fields (5 * 2 = 10)
-     *
-     * @param witnessScript The witness script to check
-     * @returns true if this is a P2WDA witness script
      */
-    public static isP2WDAWitnessScript(witnessScript: Buffer): boolean {
+    public static isP2WDAWitnessScript(witnessScript: Uint8Array): boolean {
         try {
             const decompiled = script.decompile(witnessScript);
 
@@ -55,7 +42,7 @@ export class P2WDADetector {
 
             // Check for pubkey and OP_CHECKSIG
             return (
-                Buffer.isBuffer(decompiled[5]) &&
+                decompiled[5] instanceof Uint8Array &&
                 decompiled[5].length === 33 && // Compressed public key
                 decompiled[6] === opcodes.OP_CHECKSIG
             );
@@ -66,16 +53,12 @@ export class P2WDADetector {
 
     /**
      * Generate a P2WDA address from a public key
-     *
-     * @param publicKey The public key to use (33 bytes compressed)
-     * @param network The Bitcoin network
-     * @returns The P2WDA address and related payment information
      */
     public static generateP2WDAAddress(
-        publicKey: Buffer,
+        publicKey: Uint8Array,
         network: Network,
     ): IP2WSHAddress & {
-        scriptPubKey: Buffer;
+        scriptPubKey: Uint8Array;
     } {
         if (publicKey.length !== 33) {
             throw new Error('Public key must be 33 bytes (compressed)');
@@ -111,11 +94,8 @@ export class P2WDADetector {
 
     /**
      * Extract the public key from a P2WDA witness script
-     *
-     * @param witnessScript The P2WDA witness script
-     * @returns The public key or null if not a valid P2WDA script
      */
-    public static extractPublicKeyFromP2WDA(witnessScript: Buffer): Buffer | null {
+    public static extractPublicKeyFromP2WDA(witnessScript: Uint8Array): Uint8Array | null {
         try {
             const decompiled = script.decompile(witnessScript);
 
@@ -131,7 +111,7 @@ export class P2WDADetector {
             }
 
             if (
-                Buffer.isBuffer(decompiled[5]) &&
+                decompiled[5] instanceof Uint8Array &&
                 decompiled[5].length === 33 &&
                 decompiled[6] === opcodes.OP_CHECKSIG
             ) {
@@ -146,23 +126,16 @@ export class P2WDADetector {
 
     /**
      * Create witness data for a simple P2WDA spend (no operation data)
-     *
-     * For simple transfers, P2WDA requires 10 dummy witness items (zeros) before the signature
-     *
-     * @param transactionSignature The transaction signature
-     * @param witnessScript The P2WDA witness script
-     * @returns The witness stack for a simple P2WDA spend
      */
     public static createSimpleP2WDAWitness(
-        transactionSignature: Buffer,
-        witnessScript: Buffer,
-    ): Buffer[] {
-        const witnessStack: Buffer[] = [transactionSignature];
+        transactionSignature: Uint8Array,
+        witnessScript: Uint8Array,
+    ): Uint8Array[] {
+        const witnessStack: Uint8Array[] = [transactionSignature];
 
         // Add 10 empty buffers for the 5x OP_2DROP operations
-        // Bitcoin stack is reversed!
         for (let i = 0; i < 10; i++) {
-            witnessStack.push(Buffer.alloc(0));
+            witnessStack.push(new Uint8Array(0));
         }
 
         witnessStack.push(witnessScript);
@@ -171,48 +144,26 @@ export class P2WDADetector {
 
     /**
      * Validate P2WDA operation data signature
-     *
-     * @param publicKey The public key from the witness script
-     * @param dataSignature The Schnorr signature
-     * @param operationData The operation data that was signed
-     * @returns true if the signature is valid
      */
     public static validateP2WDASignature(
-        publicKey: Buffer,
-        dataSignature: Buffer,
-        operationData: Buffer,
+        _publicKey: Uint8Array,
+        dataSignature: Uint8Array,
+        _operationData: Uint8Array,
     ): boolean {
-        // This would use MessageSigner.verifySignature internally
-        // For now, we'll assume the signature validation is handled by MessageSigner
         return dataSignature.length === 64; // Schnorr signatures are always 64 bytes
     }
 
     /**
      * Calculate the witness size for P2WDA transaction estimation
-     *
-     * @param dataSize The size of the operation data (0 for simple transfers)
-     * @returns The estimated witness size in bytes
      */
     public static estimateP2WDAWitnessSize(dataSize: number = 0): number {
-        // Witness structure:
-        // - Transaction signature: ~72 bytes
-        // - 10 data fields (can be empty or contain data)
-        // - Witness script: 39 bytes (5x OP_2DROP + 33-byte pubkey + OP_CHECKSIG)
-        // - Overhead for length prefixes: ~12 bytes (1 byte per witness element)
-
-        // For simple transfers, dataSize is 0 (10 empty fields)
-        // For interactions, dataSize is the total size of data split across fields
         return 72 + dataSize + 39 + 12;
     }
 
     /**
      * Check if a scriptPubKey is a P2WSH that could be P2WDA
-     *
-     * @param scriptPubKey The script public key to check
-     * @returns true if this could be a P2WDA output
      */
-    public static couldBeP2WDA(scriptPubKey: Buffer): boolean {
-        // P2WDA uses P2WSH, which is version 0 witness with 32-byte program
-        return scriptPubKey.length === 34 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x20; // 32 bytes
+    public static couldBeP2WDA(scriptPubKey: Uint8Array): boolean {
+        return scriptPubKey.length === 34 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x20;
     }
 }

package/src/polyfill/disposable.ts

@@ -0,0 +1,29 @@
+/**
+ * Polyfill for Symbol.dispose and Symbol.asyncDispose.
+ *
+ * ES2024 Explicit Resource Management defines these well-known symbols,
+ * but Safari and Android WebView do not yet support them. This polyfill
+ * creates globally-shared symbols via Symbol.for() so that classes can
+ * implement [Symbol.dispose]() and [Symbol.asyncDispose]() today.
+ *
+ * When native support lands, the guards prevent the polyfill from running
+ * and the native symbols are used transparently.
+ *
+ * NOTE: This file must be imported before any module that references
+ * Symbol.dispose or Symbol.asyncDispose at the module-evaluation scope.
+ */
+
+interface PolyfillableSymbolConstructor {
+    dispose?: symbol;
+    asyncDispose?: symbol;
+}
+
+const S = Symbol as unknown as PolyfillableSymbolConstructor;
+
+if (typeof S.dispose !== 'symbol') {
+    S.dispose = Symbol.for('Symbol.dispose');
+}
+
+if (typeof S.asyncDispose !== 'symbol') {
+    S.asyncDispose = Symbol.for('Symbol.asyncDispose');
+}

package/src/signer/AddressRotation.ts

@@ -1,4 +1,4 @@
-import { RotationSignerBase } from './IRotationSigner.js';
+import type { RotationSignerBase } from './IRotationSigner.js';
 import { UnisatSigner } from '../transaction/browser/extensions/UnisatSigner.js';
 
 /**