@etherkit/viem-tx-tracker 0.0.4 → 0.0.6

package/dist/TrackedWalletClient.js

@@ -24,38 +24,189 @@ function normalizeAccount(account) {
     return account === null ? undefined : account;
 }
 /**
- * Generate a unique tracking ID if not provided in metadata
+ * Infer transaction type from provided params.
+ * Returns undefined if can't be determined (wallet will decide).
  */
-function generateTrackingId() {
-    return crypto.randomUUID();
+function inferTxType(params) {
+    if (params.maxFeePerGas !== undefined) {
+        return 'eip1559';
+    }
+    if (params.gasPrice !== undefined && params.accessList !== undefined) {
+        return 'eip2930';
+    }
+    if (params.gasPrice !== undefined) {
+        return 'legacy';
+    }
+    return undefined; // Wallet will determine
 }
 /**
- * Create a tracked wallet client that wraps a viem WalletClient.
- *
- * The tracked client provides the same API as WalletClient but with:
- * - Metadata field for transaction tracking (required unless TMetadata includes undefined)
- * - Automatic nonce fetching (with 'pending' by default)
- * - Post-broadcast transaction verification
- * - Event emission for tracking
- *
- * @typeParam TMetadata - The metadata type. Use `MyMeta | undefined` to make metadata optional.
- * @returns A builder with a `.using()` method to provide the wallet and public clients
- *
- * @example
- * ```typescript
- * // With required metadata
- * const tracked = createTrackedWalletClient<{purpose: string}>()
- *   .using(walletClient, publicClient);
- *
- * // With optional metadata
- * const tracked = createTrackedWalletClient<{purpose: string} | undefined>()
- *   .using(walletClient, publicClient);
- * ```
+ * Create an UnknownTrackedTransaction for immediate emission.
+ * Populates all known intended values from the transaction parameters.
  */
-export function createTrackedWalletClient() {
+function createUnknownTrackedTransaction(hash, from, nonce, chainId, metadata, broadcastTimestampMs, params) {
+    const txType = inferTxType(params);
+    return {
+        known: false,
+        chainId,
+        hash,
+        from,
+        nonce,
+        broadcastTimestampMs,
+        metadata,
+        ...(txType !== undefined && { txType }),
+        ...(params.to !== undefined && { to: params.to }),
+        ...(params.value !== undefined && { value: params.value }),
+        ...(params.data !== undefined && { data: params.data }),
+        ...(params.gas !== undefined && { gas: params.gas }),
+        ...(params.gasPrice !== undefined && { gasPrice: params.gasPrice }),
+        ...(params.maxFeePerGas !== undefined && {
+            maxFeePerGas: params.maxFeePerGas,
+        }),
+        ...(params.maxPriorityFeePerGas !== undefined && {
+            maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+        }),
+        ...(params.accessList !== undefined && { accessList: params.accessList }),
+    };
+}
+/**
+ * Extract transaction type-specific fields from a fetched transaction.
+ */
+function extractTransactionTypeFields(tx) {
+    if (tx.type === 'eip1559') {
+        return {
+            txType: 'eip1559',
+            maxFeePerGas: tx.maxFeePerGas,
+            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+            ...(tx.accessList && { accessList: tx.accessList }),
+        };
+    }
+    else if (tx.type === 'eip2930') {
+        return {
+            txType: 'eip2930',
+            gasPrice: tx.gasPrice,
+            accessList: (tx.accessList ?? []),
+        };
+    }
+    else {
+        // Legacy or unknown - treat as legacy
+        return {
+            txType: 'legacy',
+            gasPrice: tx.gasPrice,
+        };
+    }
+}
+/**
+ * Create a KnownTrackedTransaction from a fetched transaction.
+ */
+function createKnownTrackedTransaction(tx, metadata, broadcastTimestampMs) {
+    const typeFields = extractTransactionTypeFields(tx);
+    return {
+        known: true,
+        chainId: tx.chainId,
+        hash: tx.hash,
+        from: tx.from,
+        to: tx.to,
+        nonce: tx.nonce,
+        value: tx.value,
+        data: tx.input,
+        gas: tx.gas,
+        broadcastTimestampMs,
+        metadata,
+        ...typeFields,
+    };
+}
+/**
+ * Create a KnownTrackedTransaction from a parsed raw transaction.
+ */
+function createKnownTrackedTransactionFromRaw(parsedTx, from, hash, metadata, chainId, broadcastTimestampMs) {
+    // Determine transaction type from parsed tx
+    let typeFields;
+    if ('maxFeePerGas' in parsedTx && parsedTx.maxFeePerGas !== undefined) {
+        typeFields = {
+            txType: 'eip1559',
+            maxFeePerGas: parsedTx.maxFeePerGas,
+            maxPriorityFeePerGas: parsedTx.maxPriorityFeePerGas,
+            ...('accessList' in parsedTx &&
+                parsedTx.accessList && {
+                accessList: parsedTx.accessList,
+            }),
+        };
+    }
+    else if ('accessList' in parsedTx && parsedTx.accessList) {
+        typeFields = {
+            txType: 'eip2930',
+            gasPrice: parsedTx.gasPrice,
+            accessList: parsedTx.accessList,
+        };
+    }
+    else {
+        typeFields = {
+            txType: 'legacy',
+            gasPrice: parsedTx.gasPrice,
+        };
+    }
+    return {
+        known: true,
+        chainId: parsedTx.chainId ?? chainId,
+        hash,
+        from,
+        to: parsedTx.to ?? null,
+        nonce: parsedTx.nonce,
+        value: parsedTx.value ?? 0n,
+        data: parsedTx.data ?? '0x',
+        gas: parsedTx.gas,
+        broadcastTimestampMs,
+        metadata,
+        ...typeFields,
+    };
+}
+/**
+ * Extract intended params from sendTransaction args.
+ * Uses 'unknown' for 'to' since viem's SendTransactionParameters has a complex type for it.
+ */
+function extractIntendedParamsFromSendTransaction(args) {
+    // Normalize 'to' to either a hex address, null, or undefined
+    const to = args.to === null || args.to === undefined
+        ? args.to
+        : typeof args.to === 'string'
+            ? args.to
+            : undefined;
+    return {
+        to,
+        value: args.value ?? 0n,
+        data: args.data,
+        gas: args.gas,
+        gasPrice: args.gasPrice,
+        maxFeePerGas: args.maxFeePerGas,
+        maxPriorityFeePerGas: args.maxPriorityFeePerGas,
+        accessList: args.accessList,
+    };
+}
+/**
+ * Extract intended params from writeContract args.
+ */
+function extractIntendedParamsFromWriteContract(args) {
+    return {
+        to: args.address,
+        value: args.value ?? 0n,
+        // Note: data could be encoded using encodeFunctionData(args) if desired
+        gas: args.gas,
+        gasPrice: args.gasPrice,
+        maxFeePerGas: args.maxFeePerGas,
+        maxPriorityFeePerGas: args.maxPriorityFeePerGas,
+        accessList: args.accessList,
+    };
+}
+// Implementation
+export function createTrackedWalletClient(options) {
+    const populateMetadata = options?.populateMetadata ?? false;
+    const clock = options?.clock ?? Date.now;
+    if (populateMetadata) {
+        return createAutoPopulateBuilder(clock);
+    }
     return {
         using(walletClient, publicClient) {
-            // Create emitter for transaction broadcast events
+            // Create emitter for transaction events
             const emitter = new Emitter();
             /**
              * Resolve the nonce to use for a transaction.
@@ -96,104 +247,263 @@ export function createTrackedWalletClient() {
                 return { from, intendedNonce };
             }
             /**
-             * Extract transaction context from a serialized (signed) transaction.
-             * Parses the transaction and recovers the sender address.
-             *
-             * @param serializedTransaction - The RLP-encoded signed transaction
-             * @returns TransactionContext with from address and nonce
+             * Fetch full transaction data and emit transaction:fetched event.
+             * Non-blocking, runs in background. Does not throw.
+             */
+            async function fetchAndEmitFullData(hash, metadata, broadcastTimestampMs) {
+                try {
+                    const tx = await publicClient.getTransaction({ hash });
+                    const knownTx = createKnownTrackedTransaction(tx, metadata, broadcastTimestampMs);
+                    emitter.emit('transaction:fetched', knownTx);
+                }
+                catch (error) {
+                    // Log but don't throw - transaction:fetched simply won't fire
+                    console.warn(`[TrackedWalletClient] Could not fetch tx ${hash}. ` +
+                        `transaction:fetched event will not be emitted. Error: ${error}`);
+                }
+            }
+            /**
+             * Common wrapper for transaction methods that broadcast (sendTransaction, writeContract).
+             * Emits transaction:broadcasted immediately with intended values,
+             * then fetches and emits transaction:fetched with actual values.
              */
-            async function extractRawTransactionContext(serializedTransaction) {
-                // Parse the serialized transaction to get the nonce
+            async function executeTrackedTransaction(args) {
+                const { metadata, restArgs, intendedParams, execute, extractHash } = args;
+                const broadcastTimestampMs = clock();
+                // Extract common context
+                const { from, intendedNonce } = await extractTransactionContext(args);
+                // Execute the underlying transaction with nonce injected
+                const result = await execute({
+                    ...restArgs,
+                    nonce: intendedNonce,
+                });
+                const hash = extractHash(result);
+                // Emit transaction:broadcasted immediately with intended values
+                const unknownTx = createUnknownTrackedTransaction(hash, from, intendedNonce, walletClient.chain?.id, metadata, broadcastTimestampMs, intendedParams);
+                emitter.emit('transaction:broadcasted', unknownTx);
+                // Fire-and-forget: fetch full data and emit transaction:fetched
+                fetchAndEmitFullData(hash, metadata, broadcastTimestampMs);
+                return result;
+            }
+            /**
+             * Common wrapper for raw transaction broadcasts (sendRawTransaction).
+             * For raw transactions, we can parse full data immediately.
+             * Emits KnownTrackedTransaction directly to transaction:broadcasted.
+             */
+            async function executeTrackedRawTransaction(args) {
+                const { serializedTransaction, metadata, execute, extractHash } = args;
+                const broadcastTimestampMs = clock();
+                const from = await recoverTransactionAddress({ serializedTransaction });
                 const parsedTx = parseTransaction(serializedTransaction);
-                if (parsedTx.nonce === undefined) {
-                    throw new Error('[TrackedWalletClient] Could not extract nonce from serialized transaction.');
+                // Execute the broadcast
+                const result = await execute();
+                const hash = extractHash(result);
+                // For raw transactions, we can parse full data immediately
+                const knownTx = createKnownTrackedTransactionFromRaw(parsedTx, from, hash, metadata, walletClient.chain?.id, broadcastTimestampMs);
+                // Emit as KnownTrackedTransaction since we have all data
+                emitter.emit('transaction:broadcasted', knownTx);
+                // Also emit to transaction:fetched for consistency
+                emitter.emit('transaction:fetched', knownTx);
+                return result;
+            }
+            return {
+                walletClient: walletClient,
+                publicClient,
+                // ============================================
+                // Async methods (return hash)
+                // ============================================
+                async writeContract(args) {
+                    const { metadata, nonce, ...writeArgs } = args;
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: writeArgs,
+                        intendedParams,
+                        execute: (argsWithNonce) => walletClient.writeContract(argsWithNonce),
+                        extractHash: (hash) => hash,
+                    });
+                },
+                async sendTransaction(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    const intendedParams = extractIntendedParamsFromSendTransaction(args);
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        intendedParams,
+                        execute: (argsWithNonce) => walletClient.sendTransaction(argsWithNonce),
+                        extractHash: (hash) => hash,
+                    });
+                },
+                async sendRawTransaction(args) {
+                    const { metadata, serializedTransaction } = args;
+                    return executeTrackedRawTransaction({
+                        serializedTransaction,
+                        metadata: metadata,
+                        execute: () => walletClient.sendRawTransaction({ serializedTransaction }),
+                        extractHash: (hash) => hash,
+                    });
+                },
+                // ============================================
+                // Sync methods (return receipt, wait for confirmation)
+                // ============================================
+                async writeContractSync(args) {
+                    const { metadata, nonce, ...writeArgs } = args;
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: writeArgs,
+                        intendedParams,
+                        execute: (argsWithNonce) => walletClient.writeContractSync(argsWithNonce),
+                        extractHash: (receipt) => receipt.transactionHash,
+                    });
+                },
+                async sendTransactionSync(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    const intendedParams = extractIntendedParamsFromSendTransaction(args);
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        intendedParams,
+                        execute: (argsWithNonce) => walletClient.sendTransactionSync(argsWithNonce),
+                        extractHash: (receipt) => receipt.transactionHash,
+                    });
+                },
+                async sendRawTransactionSync(args) {
+                    const { metadata, serializedTransaction } = args;
+                    return executeTrackedRawTransaction({
+                        serializedTransaction,
+                        metadata: metadata,
+                        execute: () => walletClient.sendRawTransactionSync({ serializedTransaction }),
+                        extractHash: (receipt) => receipt.transactionHash,
+                    });
+                },
+                // ============================================
+                // Event subscription methods
+                // ============================================
+                on: emitter.on.bind(emitter),
+                off: emitter.off.bind(emitter),
+            };
+        },
+    };
+}
+/**
+ * Create an auto-populate builder for TrackedWalletClient.
+ * This builder auto-populates operation, functionName and args in writeContract metadata.
+ */
+function createAutoPopulateBuilder(clock) {
+    return {
+        using(walletClient, publicClient) {
+            // Create emitter for transaction events
+            const emitter = new Emitter();
+            /**
+             * Resolve the nonce to use for a transaction.
+             */
+            async function resolveNonce(nonceOption, from) {
+                if (typeof nonceOption === 'number') {
+                    return nonceOption;
                 }
-                // Recover the sender address from the signature
-                const from = await recoverTransactionAddress({
-                    serializedTransaction,
+                const blockTag = isBlockTag(nonceOption) ? nonceOption : 'pending';
+                return await publicClient.getTransactionCount({
+                    address: from,
+                    blockTag,
                 });
-                return {
-                    from,
-                    intendedNonce: parsedTx.nonce,
-                };
             }
             /**
-             * Fetch the transaction after broadcast to verify nonce.
-             * Logs a warning if the nonce was overridden or if tx cannot be found.
-             *
-             * @param hash - The transaction hash
-             * @param intendedNonce - The nonce we intended to use
-             * @returns The actual nonce, or the intended nonce if fetch failed
+             * Extract common transaction context (account, nonce) from request args.
+             */
+            async function extractTransactionContext(args) {
+                const account = args.account ?? walletClient.account;
+                const from = resolveAccountAddress(account);
+                if (!from) {
+                    throw new Error('[TrackedWalletClient] No account available. ' +
+                        'Provide an account in the request or configure the wallet client with an account.');
+                }
+                const intendedNonce = await resolveNonce(args.nonce, from);
+                return { from, intendedNonce };
+            }
+            /**
+             * Fetch full transaction data and emit transaction:fetched event.
+             * Non-blocking, runs in background. Does not throw.
              */
-            async function verifyTransactionNonce(hash, intendedNonce) {
+            async function fetchAndEmitFullData(hash, metadata, broadcastTimestampMs) {
                 try {
                     const tx = await publicClient.getTransaction({ hash });
-                    const actualNonce = tx.nonce;
-                    if (actualNonce !== intendedNonce) {
-                        console.warn(`[TrackedWalletClient] Nonce mismatch: intended ${intendedNonce}, actual ${actualNonce}. ` +
-                            `Wallet may have overridden the nonce.`);
-                    }
-                    return actualNonce;
+                    const knownTx = createKnownTrackedTransaction(tx, metadata, broadcastTimestampMs);
+                    emitter.emit('transaction:fetched', knownTx);
                 }
-                catch (fetchError) {
-                    // Transaction not found in mempool/chain yet
-                    console.warn(`[TrackedWalletClient] Could not fetch tx ${hash} after broadcast. ` +
-                        `It may not be in the mempool yet.`);
-                    return intendedNonce;
+                catch (error) {
+                    // Log but don't throw - transaction:fetched simply won't fire
+                    console.warn(`[TrackedWalletClient] Could not fetch tx ${hash}. ` +
+                        `transaction:fetched event will not be emitted. Error: ${error}`);
                 }
             }
             /**
-             * Create a tracked transaction record.
+             * Validate that user didn't provide operation, functionName or args in metadata
+             * when populateMetadata is enabled.
              */
-            function createTrackedTransactionRecord(txHash, from, nonce, metadata) {
-                return {
-                    hash: txHash,
-                    from,
-                    nonce,
-                    chainId: walletClient.chain?.id,
-                    metadata,
-                    broadcastTimestampMs: Date.now(),
-                };
+            function validateNoAutoPopulatedFieldsInMetadata(userMetadata) {
+                if (userMetadata && typeof userMetadata === 'object') {
+                    if ('type' in userMetadata) {
+                        throw new Error('[TrackedWalletClient] Cannot specify type in metadata when populateMetadata is enabled. ' +
+                            'The type is automatically populated from the contract call.');
+                    }
+                    if ('functionName' in userMetadata) {
+                        throw new Error('[TrackedWalletClient] Cannot specify functionName in metadata when populateMetadata is enabled. ' +
+                            'The functionName is automatically populated from the contract call.');
+                    }
+                    if ('args' in userMetadata) {
+                        throw new Error('[TrackedWalletClient] Cannot specify args in metadata when populateMetadata is enabled. ' +
+                            'The args are automatically populated from the contract call.');
+                    }
+                }
             }
             /**
-             * Common wrapper for transaction methods that broadcast (sendTransaction, writeContract).
-             * Handles nonce resolution, underlying call, post-broadcast verification, and tracking record creation.
+             * Common wrapper for transaction methods that broadcast.
+             * Emits transaction:broadcasted immediately with intended values,
+             * then fetches and emits transaction:fetched with actual values.
              */
             async function executeTrackedTransaction(args) {
-                const { metadata, restArgs, execute, extractHash } = args;
-                // Extract common context
+                const { metadata, restArgs, intendedParams, execute, extractHash } = args;
+                const broadcastTimestampMs = clock();
                 const { from, intendedNonce } = await extractTransactionContext(args);
-                // Execute the underlying transaction with nonce injected
                 const result = await execute({
                     ...restArgs,
                     nonce: intendedNonce,
                 });
                 const hash = extractHash(result);
-                // Verify transaction and get actual nonce
-                const actualNonce = await verifyTransactionNonce(hash, intendedNonce);
-                // Create tracked transaction record
-                const trackedTx = createTrackedTransactionRecord(hash, from, actualNonce, metadata);
-                // Emit transaction broadcasted event
-                emitter.emit('transaction:broadcasted', trackedTx);
+                // Emit transaction:broadcasted immediately with intended values
+                const unknownTx = createUnknownTrackedTransaction(hash, from, intendedNonce, walletClient.chain?.id, metadata, broadcastTimestampMs, intendedParams);
+                emitter.emit('transaction:broadcasted', unknownTx);
+                // Fire-and-forget: fetch full data and emit transaction:fetched
+                fetchAndEmitFullData(hash, metadata, broadcastTimestampMs);
                 return result;
             }
             /**
-             * Common wrapper for raw transaction broadcasts (sendRawTransaction).
-             * Decodes the transaction to extract from/nonce, broadcasts, and creates tracking record.
+             * Common wrapper for raw transaction broadcasts.
+             * For raw transactions, we can parse full data immediately.
+             * Emits KnownTrackedTransaction directly to transaction:broadcasted.
              */
             async function executeTrackedRawTransaction(args) {
                 const { serializedTransaction, metadata, execute, extractHash } = args;
-                // Extract context from the serialized transaction
-                const { from, intendedNonce } = await extractRawTransactionContext(serializedTransaction);
+                const broadcastTimestampMs = clock();
+                const from = await recoverTransactionAddress({ serializedTransaction });
+                const parsedTx = parseTransaction(serializedTransaction);
                 // Execute the broadcast
                 const result = await execute();
                 const hash = extractHash(result);
-                // For raw transactions, the nonce is already embedded, so no verification needed
-                // (wallet cannot override nonce in an already-signed transaction)
-                // Create tracked transaction record
-                const trackedTx = createTrackedTransactionRecord(hash, from, intendedNonce, metadata);
-                // Emit transaction broadcasted event
-                emitter.emit('transaction:broadcasted', trackedTx);
+                // For raw transactions, we can parse full data immediately
+                const knownTx = createKnownTrackedTransactionFromRaw(parsedTx, from, hash, metadata, walletClient.chain?.id, broadcastTimestampMs);
+                // Emit as KnownTrackedTransaction since we have all data
+                emitter.emit('transaction:broadcasted', knownTx);
+                // We do not emit fetched as the tx is already known
                 return result;
             }
             return {
@@ -203,23 +513,36 @@ export function createTrackedWalletClient() {
                 // Async methods (return hash)
                 // ============================================
                 async writeContract(args) {
-                    const { metadata, nonce, ...writeArgs } = args;
+                    const { metadata: userMetadata, nonce, ...writeArgs } = args;
+                    // Validate that user didn't provide operation, functionName or args
+                    validateNoAutoPopulatedFieldsInMetadata(userMetadata);
+                    // Auto-populate type, functionName and args
+                    const finalMetadata = {
+                        ...(userMetadata ?? {}),
+                        type: 'functionCall',
+                        functionName: args.functionName,
+                        args: args.args,
+                    };
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
-                        metadata: metadata,
+                        metadata: finalMetadata,
                         restArgs: writeArgs,
+                        intendedParams,
                         execute: (argsWithNonce) => walletClient.writeContract(argsWithNonce),
                         extractHash: (hash) => hash,
                     });
                 },
                 async sendTransaction(args) {
                     const { metadata, nonce, ...sendArgs } = args;
+                    const intendedParams = extractIntendedParamsFromSendTransaction(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
                         metadata: metadata,
                         restArgs: sendArgs,
+                        intendedParams,
                         execute: (argsWithNonce) => walletClient.sendTransaction(argsWithNonce),
                         extractHash: (hash) => hash,
                     });
@@ -237,23 +560,36 @@ export function createTrackedWalletClient() {
                 // Sync methods (return receipt, wait for confirmation)
                 // ============================================
                 async writeContractSync(args) {
-                    const { metadata, nonce, ...writeArgs } = args;
+                    const { metadata: userMetadata, nonce, ...writeArgs } = args;
+                    // Validate that user didn't provide operation, functionName or args
+                    validateNoAutoPopulatedFieldsInMetadata(userMetadata);
+                    // Auto-populate type, functionName and args
+                    const finalMetadata = {
+                        ...(userMetadata ?? {}),
+                        type: 'functionCall',
+                        functionName: args.functionName,
+                        args: args.args,
+                    };
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
-                        metadata: metadata,
+                        metadata: finalMetadata,
                         restArgs: writeArgs,
+                        intendedParams,
                         execute: (argsWithNonce) => walletClient.writeContractSync(argsWithNonce),
                         extractHash: (receipt) => receipt.transactionHash,
                     });
                 },
                 async sendTransactionSync(args) {
                     const { metadata, nonce, ...sendArgs } = args;
+                    const intendedParams = extractIntendedParamsFromSendTransaction(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
                         metadata: metadata,
                         restArgs: sendArgs,
+                        intendedParams,
                         execute: (argsWithNonce) => walletClient.sendTransactionSync(argsWithNonce),
                         extractHash: (receipt) => receipt.transactionHash,
                     });
@@ -270,8 +606,8 @@ export function createTrackedWalletClient() {
                 // ============================================
                 // Event subscription methods
                 // ============================================
-                onTransactionBroadcasted: (listener) => emitter.on('transaction:broadcasted', listener),
-                offTransactionBroadcasted: (listener) => emitter.off('transaction:broadcasted', listener),
+                on: emitter.on.bind(emitter),
+                off: emitter.off.bind(emitter),
             };
         },
     };