@etherkit/viem-tx-tracker 0.0.5 → 0.0.6

package/dist/TrackedWalletClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TrackedWalletClient.d.ts","sourceRoot":"","sources":["../src/TrackedWalletClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAIN,KAAK,OAAO,EAEZ,KAAK,KAAK,EAIV,KAAK,YAAY,EAGjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAIX,iBAAiB,EAIjB,mBAAmB,EACnB,+BAA+B,EAG/B,MAAM,YAAY,CAAC;AA+CpB;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,IACpB,CAAC,SAAS,YAAY,CAAC,MAAM,UAAU,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,UAAU,GAAG,SAAS,CAAC;AAE7E;;GAEG;AACH,KAAK,UAAU,CAAC,CAAC,IAChB,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;AAE7E;;GAEG;AACH,KAAK,YAAY,CAAC,CAAC,IAClB,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC,GAC7C,QAAQ,GACR,OAAO,GAAG,SAAS,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,0BAA0B,CAAC,SAAS;IACpD;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,SAAS,YAAY,EACjC,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,YAAY,GACxB,mBAAmB,CACrB,SAAS,EACT,cAAc,CAAC,OAAO,CAAC,EACvB,UAAU,CAAC,OAAO,CAAC,EACnB,YAAY,CAAC,OAAO,CAAC,CACrB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,WAAW,sCAAsC,CAAC,SAAS;IAChE;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,SAAS,YAAY,EACjC,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,YAAY,GACxB,+BAA+B,CACjC,SAAS,EACT,cAAc,CAAC,OAAO,CAAC,EACvB,UAAU,CAAC,OAAO,CAAC,EACnB,YAAY,CAAC,OAAO,CAAC,CACrB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,yBAAyB,CACxC,SAAS,KACL,0BAA0B,CAAC,SAAS,CAAC,CAAC;AAG3C,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAClD,gBAAgB,EAAE,IAAI,CAAC;CACvB,GAAG,sCAAsC,CAAC,iBAAiB,CAAC,CAAC;AAG9D,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,EAAE;IAC7D,gBAAgB,EAAE,IAAI,CAAC;CACvB,GAAG,sCAAsC,CAAC,SAAS,CAAC,CAAC"}
+{"version":3,"file":"TrackedWalletClient.d.ts","sourceRoot":"","sources":["../src/TrackedWalletClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,KAAK,OAAO,EAEZ,KAAK,KAAK,EAIV,KAAK,YAAY,EAIjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAMX,iBAAiB,EAIjB,mBAAmB,EACnB,+BAA+B,EAI/B,MAAM,YAAY,CAAC;AA+RpB;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,IACpB,CAAC,SAAS,YAAY,CAAC,MAAM,UAAU,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,UAAU,GAAG,SAAS,CAAC;AAE7E;;GAEG;AACH,KAAK,UAAU,CAAC,CAAC,IAChB,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;AAE7E;;GAEG;AACH,KAAK,YAAY,CAAC,CAAC,IAClB,CAAC,SAAS,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC,GAC7C,QAAQ,GACR,OAAO,GAAG,SAAS,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,0BAA0B,CAAC,SAAS;IACpD;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,SAAS,YAAY,EACjC,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,YAAY,GACxB,mBAAmB,CACrB,SAAS,EACT,cAAc,CAAC,OAAO,CAAC,EACvB,UAAU,CAAC,OAAO,CAAC,EACnB,YAAY,CAAC,OAAO,CAAC,CACrB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,WAAW,sCAAsC,CAAC,SAAS;IAChE;;;;;;;OAOG;IACH,KAAK,CAAC,OAAO,SAAS,YAAY,EACjC,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,YAAY,GACxB,+BAA+B,CACjC,SAAS,EACT,cAAc,CAAC,OAAO,CAAC,EACvB,UAAU,CAAC,OAAO,CAAC,EACnB,YAAY,CAAC,OAAO,CAAC,CACrB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,yBAAyB,CACxC,SAAS,KACL,0BAA0B,CAAC,SAAS,CAAC,CAAC;AAG3C,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAClD,gBAAgB,EAAE,IAAI,CAAC;CACvB,GAAG,sCAAsC,CAAC,iBAAiB,CAAC,CAAC;AAG9D,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,EAAE;IAC7D,gBAAgB,EAAE,IAAI,CAAC;CACvB,GAAG,sCAAsC,CAAC,SAAS,CAAC,CAAC"}

package/dist/TrackedWalletClient.js

@@ -24,20 +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 an UnknownTrackedTransaction for immediate emission.
+ * Populates all known intended values from the transaction parameters.
+ */
+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();
+        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.
@@ -78,71 +247,29 @@ export function createTrackedWalletClient(options) {
                 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
+             * 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.
-             */
-            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.
+             * 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;
+                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
@@ -151,31 +278,32 @@ export function createTrackedWalletClient(options) {
                     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.
+             * 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);
+                // Also emit to transaction:fetched for consistency
+                emitter.emit('transaction:fetched', knownTx);
                 return result;
             }
             return {
@@ -186,22 +314,26 @@ export function createTrackedWalletClient(options) {
                 // ============================================
                 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,
                     });
@@ -220,22 +352,26 @@ export function createTrackedWalletClient(options) {
                 // ============================================
                 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,
                     });
@@ -252,8 +388,8 @@ export function createTrackedWalletClient(options) {
                 // ============================================
                 // 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),
             };
         },
     };
@@ -262,10 +398,10 @@ export function createTrackedWalletClient(options) {
  * Create an auto-populate builder for TrackedWalletClient.
  * This builder auto-populates operation, functionName and args in writeContract metadata.
  */
-function createAutoPopulateBuilder() {
+function 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.
@@ -294,53 +430,21 @@ function createAutoPopulateBuilder() {
                 return { from, intendedNonce };
             }
             /**
-             * Extract transaction context from a serialized (signed) transaction.
+             * Fetch full transaction data and emit transaction:fetched event.
+             * Non-blocking, runs in background. Does not throw.
              */
-            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) {
+            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) {
-                    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.
-             */
-            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.
@@ -363,30 +467,43 @@ function createAutoPopulateBuilder() {
             }
             /**
              * 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;
+                const { metadata, restArgs, intendedParams, execute, extractHash } = args;
+                const broadcastTimestampMs = clock();
                 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);
+                // 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.
+             * 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 { 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);
-                const trackedTx = createTrackedTransactionRecord(hash, from, intendedNonce, metadata);
-                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 {
@@ -406,22 +523,26 @@ function createAutoPopulateBuilder() {
                         functionName: args.functionName,
                         args: args.args,
                     };
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
                         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,
                     });
@@ -449,22 +570,26 @@ function createAutoPopulateBuilder() {
                         functionName: args.functionName,
                         args: args.args,
                     };
+                    const intendedParams = extractIntendedParamsFromWriteContract(args);
                     return executeTrackedTransaction({
                         account: normalizeAccount(args.account),
                         nonce,
                         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,
                     });
@@ -481,8 +606,8 @@ function createAutoPopulateBuilder() {
                 // ============================================
                 // 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),
             };
         },
     };