@etherkit/viem-tx-tracker 0.0.3 → 0.0.5

package/dist/TrackedWalletClient.js

@@ -29,234 +29,462 @@ function normalizeAccount(account) {
 function generateTrackingId() {
     return crypto.randomUUID();
 }
-/**
- * Create a tracked wallet client that wraps a viem WalletClient.
- *
- * The tracked client provides the same API as WalletClient but with:
- * - Optional metadata field for transaction tracking
- * - Automatic nonce fetching (with 'pending' by default)
- * - Post-broadcast transaction verification
- * - TODO: Event emission for tracking
- *
- * @param walletClient - The underlying viem WalletClient
- * @param publicClient - A PublicClient for nonce fetching and tx verification
- * @returns A TrackedWalletClient instance
- */
-export function createTrackedWalletClient(walletClient, publicClient) {
-    // Create emitter for transaction broadcast events
-    const emitter = new Emitter();
-    /**
-     * Resolve the nonce to use for a transaction.
-     *
-     * @param nonceOption - The nonce option provided by the caller
-     * @param from - The sender address
-     * @returns The resolved nonce number
-     */
-    async function resolveNonce(nonceOption, from) {
-        if (typeof nonceOption === 'number') {
-            // Explicit number - use as-is
-            return nonceOption;
-        }
-        // Block tag (string) or undefined - fetch from chain
-        const blockTag = isBlockTag(nonceOption) ? nonceOption : 'pending';
-        return await publicClient.getTransactionCount({
-            address: from,
-            blockTag,
-        });
-    }
-    /**
-     * Extract common transaction context (account, nonce) from request args.
-     * This is the shared logic between all transaction methods.
-     *
-     * @param args - The transaction args containing account and nonce options
-     * @returns TransactionContext with resolved from address and nonce
-     */
-    async function extractTransactionContext(args) {
-        // Get account/from address
-        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.');
-        }
-        // Resolve nonce
-        const intendedNonce = await resolveNonce(args.nonce, from);
-        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
-     */
-    async function extractRawTransactionContext(serializedTransaction) {
-        // Parse the serialized transaction to get the nonce
-        const parsedTx = parseTransaction(serializedTransaction);
-        if (parsedTx.nonce === undefined) {
-            throw new Error('[TrackedWalletClient] Could not extract nonce from serialized transaction.');
-        }
-        // Recover the sender address from the signature
-        const from = await recoverTransactionAddress({
-            serializedTransaction,
-        });
-        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
-     */
-    async function verifyTransactionNonce(hash, intendedNonce) {
-        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;
-        }
-        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;
-        }
-    }
-    /**
-     * Create a tracked transaction record.
-     */
-    function createTrackedTransaction(txHash, from, nonce, metadata, request) {
-        return {
-            hash: txHash,
-            from,
-            nonce,
-            chainId: walletClient.chain?.id,
-            metadata: (metadata ?? {}),
-            broadcastTimestampMs: Date.now(),
-        };
-    }
-    /**
-     * Common wrapper for transaction methods that broadcast (sendTransaction, writeContract).
-     * Handles nonce resolution, underlying call, post-broadcast verification, and tracking record creation.
-     */
-    async function executeTrackedTransaction(args) {
-        const { metadata, restArgs, execute, extractHash } = args;
-        // 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);
-        // Verify transaction and get actual nonce
-        const actualNonce = await verifyTransactionNonce(hash, intendedNonce);
-        // Create tracked transaction record
-        const trackedTx = createTrackedTransaction(hash, from, actualNonce, metadata, restArgs);
-        // Emit transaction broadcasted event
-        emitter.emit('transaction:broadcasted', trackedTx);
-        return result;
-    }
-    /**
-     * Common wrapper for raw transaction broadcasts (sendRawTransaction).
-     * Decodes the transaction to extract from/nonce, broadcasts, and creates tracking record.
-     */
-    async function executeTrackedRawTransaction(args) {
-        const { serializedTransaction, metadata, execute, extractHash } = args;
-        // Extract context from the serialized transaction
-        const { from, intendedNonce } = await extractRawTransactionContext(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 = createTrackedTransaction(hash, from, intendedNonce, metadata, { serializedTransaction });
-        // Emit transaction broadcasted event
-        emitter.emit('transaction:broadcasted', trackedTx);
-        return result;
+// Implementation
+export function createTrackedWalletClient(options) {
+    const populateMetadata = options?.populateMetadata ?? false;
+    if (populateMetadata) {
+        return createAutoPopulateBuilder();
     }
     return {
-        walletClient,
-        publicClient,
-        // ============================================
-        // Async methods (return hash)
-        // ============================================
-        async writeContract(args) {
-            const { metadata, nonce, ...writeArgs } = args;
-            return executeTrackedTransaction({
-                account: normalizeAccount(args.account),
-                nonce,
-                metadata,
-                restArgs: writeArgs,
-                execute: (argsWithNonce) => walletClient.writeContract(argsWithNonce),
-                extractHash: (hash) => hash,
-            });
-        },
-        async sendTransaction(args) {
-            const { metadata, nonce, ...sendArgs } = args;
-            return executeTrackedTransaction({
-                account: normalizeAccount(args.account),
-                nonce,
-                metadata,
-                restArgs: sendArgs,
-                execute: (argsWithNonce) => walletClient.sendTransaction(argsWithNonce),
-                extractHash: (hash) => hash,
-            });
-        },
-        async sendRawTransaction(args) {
-            const { metadata, serializedTransaction } = args;
-            return executeTrackedRawTransaction({
-                serializedTransaction,
-                metadata,
-                execute: () => walletClient.sendRawTransaction({ serializedTransaction }),
-                extractHash: (hash) => hash,
-            });
-        },
-        // ============================================
-        // Sync methods (return receipt, wait for confirmation)
-        // ============================================
-        async writeContractSync(args) {
-            const { metadata, nonce, ...writeArgs } = args;
-            return executeTrackedTransaction({
-                account: normalizeAccount(args.account),
-                nonce,
-                metadata,
-                restArgs: writeArgs,
-                execute: (argsWithNonce) => walletClient.writeContractSync(argsWithNonce),
-                extractHash: (receipt) => receipt.transactionHash,
-            });
-        },
-        async sendTransactionSync(args) {
-            const { metadata, nonce, ...sendArgs } = args;
-            return executeTrackedTransaction({
-                account: normalizeAccount(args.account),
-                nonce,
-                metadata,
-                restArgs: sendArgs,
-                execute: (argsWithNonce) => walletClient.sendTransactionSync(argsWithNonce),
-                extractHash: (receipt) => receipt.transactionHash,
-            });
+        using(walletClient, publicClient) {
+            // Create emitter for transaction broadcast events
+            const emitter = new Emitter();
+            /**
+             * Resolve the nonce to use for a transaction.
+             *
+             * @param nonceOption - The nonce option provided by the caller
+             * @param from - The sender address
+             * @returns The resolved nonce number
+             */
+            async function resolveNonce(nonceOption, from) {
+                if (typeof nonceOption === 'number') {
+                    // Explicit number - use as-is
+                    return nonceOption;
+                }
+                // Block tag (string) or undefined - fetch from chain
+                const blockTag = isBlockTag(nonceOption) ? nonceOption : 'pending';
+                return await publicClient.getTransactionCount({
+                    address: from,
+                    blockTag,
+                });
+            }
+            /**
+             * Extract common transaction context (account, nonce) from request args.
+             * This is the shared logic between all transaction methods.
+             *
+             * @param args - The transaction args containing account and nonce options
+             * @returns TransactionContext with resolved from address and nonce
+             */
+            async function extractTransactionContext(args) {
+                // Get account/from address
+                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.');
+                }
+                // Resolve nonce
+                const intendedNonce = await resolveNonce(args.nonce, from);
+                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
+             */
+            async function extractRawTransactionContext(serializedTransaction) {
+                // Parse the serialized transaction to get the nonce
+                const parsedTx = parseTransaction(serializedTransaction);
+                if (parsedTx.nonce === undefined) {
+                    throw new Error('[TrackedWalletClient] Could not extract nonce from serialized transaction.');
+                }
+                // Recover the sender address from the signature
+                const from = await recoverTransactionAddress({
+                    serializedTransaction,
+                });
+                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
+             */
+            async function verifyTransactionNonce(hash, intendedNonce) {
+                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;
+                }
+                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;
+                }
+            }
+            /**
+             * Create a tracked transaction record.
+             */
+            function createTrackedTransactionRecord(txHash, from, nonce, metadata) {
+                return {
+                    hash: txHash,
+                    from,
+                    nonce,
+                    chainId: walletClient.chain?.id,
+                    metadata,
+                    broadcastTimestampMs: Date.now(),
+                };
+            }
+            /**
+             * Common wrapper for transaction methods that broadcast (sendTransaction, writeContract).
+             * Handles nonce resolution, underlying call, post-broadcast verification, and tracking record creation.
+             */
+            async function executeTrackedTransaction(args) {
+                const { metadata, restArgs, execute, extractHash } = args;
+                // 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);
+                // 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);
+                return result;
+            }
+            /**
+             * Common wrapper for raw transaction broadcasts (sendRawTransaction).
+             * Decodes the transaction to extract from/nonce, broadcasts, and creates tracking record.
+             */
+            async function executeTrackedRawTransaction(args) {
+                const { serializedTransaction, metadata, execute, extractHash } = args;
+                // Extract context from the serialized transaction
+                const { from, intendedNonce } = await extractRawTransactionContext(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);
+                return result;
+            }
+            return {
+                walletClient: walletClient,
+                publicClient,
+                // ============================================
+                // Async methods (return hash)
+                // ============================================
+                async writeContract(args) {
+                    const { metadata, nonce, ...writeArgs } = args;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: writeArgs,
+                        execute: (argsWithNonce) => walletClient.writeContract(argsWithNonce),
+                        extractHash: (hash) => hash,
+                    });
+                },
+                async sendTransaction(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        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;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: writeArgs,
+                        execute: (argsWithNonce) => walletClient.writeContractSync(argsWithNonce),
+                        extractHash: (receipt) => receipt.transactionHash,
+                    });
+                },
+                async sendTransactionSync(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        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
+                // ============================================
+                onTransactionBroadcasted: (listener) => emitter.on('transaction:broadcasted', listener),
+                offTransactionBroadcasted: (listener) => emitter.off('transaction:broadcasted', listener),
+            };
         },
-        async sendRawTransactionSync(args) {
-            const { metadata, serializedTransaction } = args;
-            return executeTrackedRawTransaction({
-                serializedTransaction,
-                metadata,
-                execute: () => walletClient.sendRawTransactionSync({ serializedTransaction }),
-                extractHash: (receipt) => receipt.transactionHash,
-            });
+    };
+}
+/**
+ * Create an auto-populate builder for TrackedWalletClient.
+ * This builder auto-populates operation, functionName and args in writeContract metadata.
+ */
+function createAutoPopulateBuilder() {
+    return {
+        using(walletClient, publicClient) {
+            // Create emitter for transaction broadcast events
+            const emitter = new Emitter();
+            /**
+             * Resolve the nonce to use for a transaction.
+             */
+            async function resolveNonce(nonceOption, from) {
+                if (typeof nonceOption === 'number') {
+                    return nonceOption;
+                }
+                const blockTag = isBlockTag(nonceOption) ? nonceOption : 'pending';
+                return await publicClient.getTransactionCount({
+                    address: from,
+                    blockTag,
+                });
+            }
+            /**
+             * 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 };
+            }
+            /**
+             * Extract transaction context from a serialized (signed) transaction.
+             */
+            async function extractRawTransactionContext(serializedTransaction) {
+                const parsedTx = parseTransaction(serializedTransaction);
+                if (parsedTx.nonce === undefined) {
+                    throw new Error('[TrackedWalletClient] Could not extract nonce from serialized transaction.');
+                }
+                const from = await recoverTransactionAddress({
+                    serializedTransaction,
+                });
+                return {
+                    from,
+                    intendedNonce: parsedTx.nonce,
+                };
+            }
+            /**
+             * Fetch the transaction after broadcast to verify nonce.
+             */
+            async function verifyTransactionNonce(hash, intendedNonce) {
+                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;
+                }
+                catch (fetchError) {
+                    console.warn(`[TrackedWalletClient] Could not fetch tx ${hash} after broadcast. ` +
+                        `It may not be in the mempool yet.`);
+                    return intendedNonce;
+                }
+            }
+            /**
+             * Create a tracked transaction record.
+             */
+            function createTrackedTransactionRecord(txHash, from, nonce, metadata) {
+                return {
+                    hash: txHash,
+                    from,
+                    nonce,
+                    chainId: walletClient.chain?.id,
+                    metadata,
+                    broadcastTimestampMs: Date.now(),
+                };
+            }
+            /**
+             * Validate that user didn't provide operation, functionName or args in metadata
+             * when populateMetadata is enabled.
+             */
+            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.
+             */
+            async function executeTrackedTransaction(args) {
+                const { metadata, restArgs, execute, extractHash } = args;
+                const { from, intendedNonce } = await extractTransactionContext(args);
+                const result = await execute({
+                    ...restArgs,
+                    nonce: intendedNonce,
+                });
+                const hash = extractHash(result);
+                const actualNonce = await verifyTransactionNonce(hash, intendedNonce);
+                const trackedTx = createTrackedTransactionRecord(hash, from, actualNonce, metadata);
+                emitter.emit('transaction:broadcasted', trackedTx);
+                return result;
+            }
+            /**
+             * Common wrapper for raw transaction broadcasts.
+             */
+            async function executeTrackedRawTransaction(args) {
+                const { serializedTransaction, metadata, execute, extractHash } = args;
+                const { from, intendedNonce } = await extractRawTransactionContext(serializedTransaction);
+                const result = await execute();
+                const hash = extractHash(result);
+                const trackedTx = createTrackedTransactionRecord(hash, from, intendedNonce, metadata);
+                emitter.emit('transaction:broadcasted', trackedTx);
+                return result;
+            }
+            return {
+                walletClient: walletClient,
+                publicClient,
+                // ============================================
+                // Async methods (return hash)
+                // ============================================
+                async writeContract(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,
+                    };
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: finalMetadata,
+                        restArgs: writeArgs,
+                        execute: (argsWithNonce) => walletClient.writeContract(argsWithNonce),
+                        extractHash: (hash) => hash,
+                    });
+                },
+                async sendTransaction(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        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: 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,
+                    };
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: finalMetadata,
+                        restArgs: writeArgs,
+                        execute: (argsWithNonce) => walletClient.writeContractSync(argsWithNonce),
+                        extractHash: (receipt) => receipt.transactionHash,
+                    });
+                },
+                async sendTransactionSync(args) {
+                    const { metadata, nonce, ...sendArgs } = args;
+                    return executeTrackedTransaction({
+                        account: normalizeAccount(args.account),
+                        nonce,
+                        metadata: metadata,
+                        restArgs: sendArgs,
+                        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
+                // ============================================
+                onTransactionBroadcasted: (listener) => emitter.on('transaction:broadcasted', listener),
+                offTransactionBroadcasted: (listener) => emitter.off('transaction:broadcasted', listener),
+            };
         },
-        // ============================================
-        // Event subscription methods
-        // ============================================
-        onTransactionBroadcasted: (listener) => emitter.on('transaction:broadcasted', listener),
-        offTransactionBroadcasted: (listener) => emitter.off('transaction:broadcasted', listener),
     };
 }
 //# sourceMappingURL=TrackedWalletClient.js.map