@etherkit/viem-tx-tracker 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Ronan Sandford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,322 @@
+# @etherkit/tx-observer
+
+A TypeScript library for monitoring Ethereum onchain operations containing multiple transactions, with automatic status merging and finality tracking.
+
+## Overview
+
+The Operation Processor tracks **operations** - logical groupings of transactions that belong together. This is useful when:
+
+- **Gas price bumping**: Multiple transactions with the same nonce but different gas prices
+- **Sequential retries**: Transactions with different nonces for the same logical action
+- **Multi-step operations**: Related transactions that form a single user action
+
+The processor monitors all transactions in an operation and computes a merged status, emitting events when the operation status changes.
+
+## Installation
+
+```bash
+npm install @etherkit/tx-observer
+```
+
+## Quick Start
+
+```typescript
+import { initTransactionProcessor } from '@etherkit/tx-observer';
+import type { OnchainOperation, BroadcastedTransaction, OnchainOperationEvent } from '@etherkit/tx-observer';
+
+// Initialize the processor
+const processor = initTransactionProcessor({
+  finality: 12, // blocks until considered final
+  throttle: 5000, // optional: throttle process() calls
+  provider: window.ethereum,
+});
+
+// Create an operation with one or more transactions
+const operation: OnchainOperation = {
+  transactions: [
+    {
+      hash: '0xabc...',
+      from: '0x123...',
+      nonce: 5,
+      broadcastTimestamp: Date.now(),
+    },
+  ],,
+};
+
+// Add the operation to tracking (ID is passed separately)
+processor.add('my-operation-1', operation);
+
+// Listen for operation status changes (for UI updates)
+processor.onOperationStatusUpdated((event: OnchainOperationEvent) => {
+  console.log(`Operation ${event.id}: ${event.operation.state?.inclusion}`);
+  
+  if (event.operation.state?.inclusion === 'Included') {
+    const winningTx = event.operation.transactions[event.operation.state.txIndex];
+    console.log(`Status: ${event.operation.state.status}`);
+    console.log(`Winning TX: ${winningTx.hash}`);
+  }
+  
+  return () => {}; // cleanup function
+});
+
+// Listen for any transaction changes (for persistence)
+processor.onOperationUpdated((event: OnchainOperationEvent) => {
+  console.log(`Operation ${event.id} updated, save to storage`);
+  return () => {}; // cleanup function
+});
+
+// Process periodically (check for status updates)
+setInterval(() => processor.process(), 5000);
+```
+
+## API Reference
+
+### `initTransactionProcessor(config)`
+
+Creates a new operation processor instance.
+
+**Config:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `finality` | `number` | Number of blocks until a transaction is considered final |
+| `throttle` | `number?` | Optional: throttle interval in ms for `process()` calls |
+| `provider` | `EIP1193ProviderWithoutEvents?` | Optional Ethereum provider (can be set later) |
+
+**Returns:** Processor instance with the following methods:
+
+#### `add(id: string, operation: OnchainOperation)`
+
+Add an operation to track. If an operation with the same ID already exists, the transactions are merged into the existing operation.
+
+```typescript
+// Add new operation
+processor.add('my-operation-1', operation);
+
+// Add another transaction to existing operation (same ID merges)
+processor.add('my-operation-1', {
+  transactions: [bumpedTx], // New tx with higher gas
+  // ... state fields
+});
+// and in case where you track the txs already you can simply re-add
+operation.transactions.push(bumpedTx);
+processor.add('my-operation-1', operation);
+```
+
+#### `addMultiple(operations: {[id: string]: OnchainOperation})`
+
+Add multiple operations at once.
+
+```typescript
+processor.addMultiple({
+  'operation-1': operation1,
+  'operation-2': operation2,
+});
+```
+
+#### `remove(operationId: string)`
+
+Remove an operation by ID and stop tracking it.
+
+```typescript
+processor.remove('my-operation-1');
+```
+
+#### `clear()`
+
+Remove all operations.
+
+```typescript
+processor.clear();
+```
+
+#### `process(): Promise<void>`
+
+Check and update the status of all tracked operations. This queries the Ethereum provider for transaction receipts and updates statuses accordingly.
+
+```typescript
+await processor.process();
+```
+
+#### `setProvider(provider: EIP1193Provider)`
+
+Update the Ethereum provider.
+
+```typescript
+processor.setProvider(newProvider);
+```
+
+#### `onOperationUpdated(listener): void`
+
+Subscribe to any operation changes (when any transaction in the operation changes). Useful for persistence.
+
+```typescript
+processor.onOperationUpdated((event: OnchainOperationEvent) => {
+  console.log(`Operation ${event.id} changed:`, event.operation);
+  return () => {}; // cleanup
+});
+```
+
+#### `offOperationUpdated(listener): void`
+
+Unsubscribe from operation changes.
+
+#### `onOperationStatusUpdated(listener): void`
+
+Subscribe to operation status changes only (when the merged status changes). Useful for UI updates.
+
+```typescript
+processor.onOperationStatusUpdated((event: OnchainOperationEvent) => {
+  console.log(`Operation ${event.id} status:`, event.operation.state?.inclusion);
+  return () => {}; // cleanup
+});
+```
+
+#### `offOperationStatusUpdated(listener): void`
+
+Unsubscribe from operation status changes.
+
+## Types
+
+### `BroadcastedTransaction`
+
+Represents a single broadcasted transaction.
+
+```typescript
+type BroadcastedTransaction = {
+  readonly hash: `0x${string}`;
+  readonly from: `0x${string}`;
+  nonce?: number;
+  readonly broadcastTimestamp: number;
+  state?: BroadcastedTransactionState;
+};
+
+type BroadcastedTransactionState =
+  | { inclusion: 'InMemPool' | 'NotFound'; final: undefined; status: undefined }
+  | { inclusion: 'Dropped'; final?: number; status: undefined }
+  | { inclusion: 'Included'; status: 'Failure' | 'Success'; final?: number };
+```
+
+### `OnchainOperationStatus`
+
+The merged status of all transactions in an operation.
+
+```typescript
+type OnchainOperationStatus =
+  | { inclusion: 'InMemPool' | 'NotFound'; final: undefined; status: undefined; txIndex: undefined }
+  | { inclusion: 'Dropped'; final?: number; status: undefined; txIndex: undefined }
+  | { inclusion: 'Included'; status: 'Failure' | 'Success'; final?: number; txIndex: number };
+```
+
+- `txIndex`: Index into `transactions[]` for the "winning" transaction (first success, or first failure if all failed)
+- Get the winning tx hash via: `operation.transactions[operation.state.txIndex].hash`
+
+### `OnchainOperation`
+
+An operation containing multiple transactions.
+
+```typescript
+type OnchainOperation = {
+  transactions: BroadcastedTransaction[];
+  state?: OnchainOperationStatus;
+};
+```
+
+### `OnchainOperationEvent`
+
+Event payload emitted by listeners, includes both the operation ID and operation data.
+
+```typescript
+type OnchainOperationEvent = {
+  id: string;
+  operation: OnchainOperation;
+};
+```
+
+## Status States
+
+| Inclusion | Description |
+|-----------|-------------|
+| `Broadcasted` | At least one transaction is visible in the mempool |
+| `NotFound` | No transactions visible in mempool (may be temporary) |
+| `Dropped` | All transactions dropped (nonce was used by external tx) |
+| `Included` | At least one transaction was included in a block |
+
+## Status Merging Logic
+
+When an operation contains multiple transactions, their statuses are merged using the following priority (highest wins):
+
+1. **Included** - Any tx included in a block → operation is `Included`
+2. **Broadcasted** - Any tx in mempool → operation is `Broadcasted`
+3. **NotFound** - None visible → operation is `NotFound`
+4. **Dropped** - ALL txs dropped → operation is `Dropped`
+
+### For `Included` Operations
+
+- If **any** transaction succeeded → `status: 'Success'`
+- If **all** included transactions failed → `status: 'Failure'`
+- `txIndex` points to the first successful tx, or first failure if all failed
+
+This allows scenarios like:
+- Tx A (nonce 5) succeeds, Tx B (nonce 6) fails due to nonce conflict → Operation is **Success**
+- Tx A (nonce 5, low gas) dropped, Tx B (nonce 5, high gas) succeeds → Operation is **Success**
+
+## Use Cases
+
+### Gas Price Bumping
+
+When network congestion increases, submit a replacement transaction with the same nonce but higher gas price:
+
+```typescript
+// Initial transaction
+const tx1: BroadcastedTransaction = {
+  hash: '0x111...',
+  from: '0xabc...',
+  nonce: 5,
+  broadcastTimestamp: Date.now(),
+  state: {
+    inclusion: 'InMemPool',
+    status: undefined,
+    final: undefined,
+  },
+};
+
+processor.add('transfer-1', {
+  transactions: [tx1],
+  state: {
+    inclusion: 'InMemPool',
+    status: undefined,
+    final: undefined,
+    txIndex: undefined,
+  },
+});
+
+// Later, bump gas price (same nonce)
+const tx2: BroadcastedTransaction = {
+  ...tx1,
+  hash: '0x222...', // Different hash
+};
+
+processor.add('transfer-1', { // Same ID → merges
+  transactions: [tx2],
+});
+
+// Operation now tracks both txs
+// Whichever is included first determines the operation result
+```
+
+### Sequential Retry
+
+If a transaction is stuck, retry with a new nonce:
+
+```typescript
+processor.add('my-action', {
+  transactions: [
+    { hash: '0x1...', from: '0xabc...', nonce: 5, broadcastTimestamp: Date.now() }, // Original
+    { hash: '0x2...', from: '0xabc...', nonce: 6, broadcastTimestamp: Date.now() }, // Retry with new nonce
+  ],
+});
+
+// If tx with nonce 5 succeeds, operation is Success
+// Even if tx with nonce 6 fails (nonce conflict), operation is still Success
+```

package/dist/TrackedWalletClient.d.ts

@@ -0,0 +1,17 @@
+import { type Account, type Chain, type PublicClient, type Transport, type WalletClient } from 'viem';
+import type { TrackedWalletClient } from './types.js';
+/**
+ * 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 declare function createTrackedWalletClient<TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined>(walletClient: WalletClient<TTransport, TChain, TAccount>, publicClient: PublicClient): TrackedWalletClient<TTransport, TChain, TAccount>;
+//# sourceMappingURL=TrackedWalletClient.d.ts.map

package/dist/TrackedWalletClient.d.ts.map

@@ -0,0 +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,EAMX,mBAAmB,EAGnB,MAAM,YAAY,CAAC;AA+CpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACxC,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACpD,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,EAE1D,YAAY,EAAE,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EACxD,YAAY,EAAE,YAAY,GACxB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CA0XnD"}

package/dist/TrackedWalletClient.js

@@ -0,0 +1,264 @@
+import { parseTransaction, recoverTransactionAddress, } from 'viem';
+import { Emitter } from 'radiate';
+/**
+ * Check if a value is a block tag string
+ */
+function isBlockTag(value) {
+    return (typeof value === 'string' &&
+        ['latest', 'pending', 'earliest', 'safe', 'finalized'].includes(value));
+}
+/**
+ * Resolve the account address from various account formats
+ */
+function resolveAccountAddress(account) {
+    if (!account)
+        return undefined;
+    if (typeof account === 'string')
+        return account;
+    return account.address;
+}
+/**
+ * Coerce potentially null account to undefined for type compatibility with extractTransactionContext
+ */
+function normalizeAccount(account) {
+    return account === null ? undefined : account;
+}
+/**
+ * Generate a unique tracking ID if not provided in metadata
+ */
+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 {
+            trackingId: metadata?.id ?? generateTrackingId(),
+            txHash,
+            from,
+            nonce,
+            chainId: walletClient.chain?.id ?? 1,
+            metadata: (metadata ?? {}),
+            initiatedAt: Date.now(),
+            request,
+        };
+    }
+    /**
+     * 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;
+    }
+    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,
+            });
+        },
+        async sendRawTransactionSync(args) {
+            const { metadata, serializedTransaction } = args;
+            return executeTrackedRawTransaction({
+                serializedTransaction,
+                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),
+    };
+}
+//# sourceMappingURL=TrackedWalletClient.js.map

package/dist/TrackedWalletClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrackedWalletClient.js","sourceRoot":"","sources":["../src/TrackedWalletClient.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { BlockTag, ExpectedEvent, NonceOption, TrackedRawTransactionParameters, TrackedSendTransactionParameters, TrackedTransaction, TrackedWalletClient, TrackedWriteContractParameters, TransactionMetadata, } from './types.js';
+export { createTrackedWalletClient } from './TrackedWalletClient.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACX,QAAQ,EACR,aAAa,EACb,WAAW,EACX,+BAA+B,EAC/B,gCAAgC,EAChC,kBAAkB,EAClB,mBAAmB,EACnB,8BAA8B,EAC9B,mBAAmB,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAC,yBAAyB,EAAC,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+// Factory
+export { createTrackedWalletClient } from './TrackedWalletClient.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,UAAU;AACV,OAAO,EAAC,yBAAyB,EAAC,MAAM,0BAA0B,CAAC"}