- Adds ability to retrieve transaction receipts

Author: pbienek

README.md

@@ -417,6 +417,11 @@ const {
 - `sendTransaction(txParams)`: Send a privacy-preserving transaction through the session key
   - `txParams`: `{ to: string, value: string, data: string }`
   - Returns: `Promise<string>` (transaction hash)
+- `waitForReceipt(txHash, timeout?)`: Wait for transaction receipt and confirmation
+  - `txHash`: Transaction hash from `sendTransaction`
+  - `timeout`: Optional timeout in milliseconds (default: 30000)
+  - Returns: `Promise<TransactionReceipt>` (full receipt with logs and status)
+  - Throws: Error if transaction reverts or timeout is exceeded
 - `createSessionKey()`: Create a new session key
 - `fundSessionKey(address, amount, userAddress)`: Fund a session key with ETH
 - `deleteSessionKey()`: Delete the current session key
@@ -426,10 +431,10 @@ const {
 **Example:**
 ```tsx
 import { useSessionKeyStore } from '@tenprotocol/ten-kit';
-import { encodeFunctionData, parseEther } from 'viem';
+import { encodeFunctionData, parseEther, parseEventLogs } from 'viem';
 
 function MyComponent() {
-  const { sessionKey, sendTransaction } = useSessionKeyStore();
+  const { sessionKey, sendTransaction, waitForReceipt } = useSessionKeyStore();
 
   const handleTransaction = async () => {
     const data = encodeFunctionData({
@@ -442,6 +447,17 @@ function MyComponent() {
       value: `0x${parseEther('0.01').toString(16)}`,
       data,
     });
+
+    // Wait for confirmation and get receipt
+    const receipt = await waitForReceipt(txHash);
+    console.log('Status:', receipt.status);
+    
+    // Parse event logs
+    const events = parseEventLogs({
+      abi: MyContractABI,
+      logs: receipt.logs,
+    });
+    console.log('Events:', events);
   };
 
   return <button onClick={handleTransaction}>Send TX</button>;
@@ -624,6 +640,7 @@ import type {
   // Session Key Types
   SessionKeyStore,
   TransactionParams,
+  TransactionReceipt,
 
   // Public Clients
   TENPublicClients,
@@ -640,6 +657,12 @@ const txParams: TransactionParams = {
   data: '0x...',
 };
 
+// Example: Working with receipts
+const receipt: TransactionReceipt = await waitForReceipt(txHash);
+console.log('Status:', receipt.status);
+console.log('Gas used:', receipt.gasUsed);
+console.log('Logs:', receipt.logs);
+
 // Example: Custom Config
 const config: TenConfig = {
   id: 8443,

src/components/TENProvider/TENProvider.tsx

@@ -1,4 +1,4 @@
-import { ReactNode } from 'react';
+import {ReactNode, useEffect} from 'react';
 import {QueryClient, QueryClientProvider} from '@tanstack/react-query';
 import { WagmiProvider, createConfig } from 'wagmi';
 import { defineChain, http } from 'viem';
@@ -36,7 +36,9 @@ export function TENProvider({
         transports,
     });
 
-    setWagmiConfig(wagmiConfig);
+    useEffect(() => {
+        setWagmiConfig(wagmiConfig);
+    }, []);
 
     return (
         <WagmiProvider config={wagmiConfig}>

src/index.ts

@@ -33,6 +33,7 @@ export type { TENPublicClients } from '@/lib/contractReadFunctions'
 export type {
     EIP1193Provider,
     TransactionParams,
+    TransactionReceipt,
     StateSubscriber,
     SessionKeyStore,
     TenConfig,

src/lib/types.ts

@@ -29,6 +29,33 @@ export interface TransactionParams {
     maxPriorityFeePerGas?: string | bigint;
 }
 
+export interface TransactionReceipt {
+    transactionHash: string;
+    transactionIndex: string;
+    blockHash: string;
+    blockNumber: string;
+    from: string;
+    to: string | null;
+    cumulativeGasUsed: string;
+    gasUsed: string;
+    contractAddress: string | null;
+    logs: Array<{
+        address: string;
+        topics: string[];
+        data: string;
+        blockNumber: string;
+        transactionHash: string;
+        transactionIndex: string;
+        blockHash: string;
+        logIndex: string;
+        removed: boolean;
+    }>;
+    logsBloom: string;
+    status: string; // '0x1' for success, '0x0' for failure
+    effectiveGasPrice: string;
+    type: string;
+}
+
 export type StateSubscriber = (state: SessionKeyState) => void;
 
 export interface SessionKeyStore {
@@ -51,6 +78,7 @@ export interface SessionKeyStore {
     cleanupSessionKey: () => Promise<void>;
     updateBalance: () => Promise<SessionBalanceObject>;
     sendTransaction: (txParams: TransactionParams) => Promise<string>;
+    waitForReceipt: (txHash: string, timeout?: number) => Promise<TransactionReceipt>;
     setWagmiConfig: (config: Config) => void;
 }
 

src/stores/sessionKey.store.ts

@@ -2,7 +2,7 @@ import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
 import { encode as rlpEncode } from 'rlp';
 
-import type {SessionKeyStore, TransactionParams, SessionBalanceObject} from '@/lib/types';
+import type {SessionKeyStore, TransactionParams, SessionBalanceObject, TransactionReceipt} from '@/lib/types';
 import { LOCAL_STORAGE_KEY, TEN_ADDRESSES } from '@/lib/constants';
 import {
     parseEther,
@@ -408,6 +408,45 @@ export const useSessionKeyStore = create<SessionKeyStore>()(
                 }
             },
 
+            waitForReceipt: async (txHash: string, timeout: number = 30000): Promise<TransactionReceipt> => {
+                try {
+                    const provider = get().provider;
+                    if (!provider) {
+                        throw new Error('No provider available');
+                    }
+
+                    const startTime = Date.now();
+                    const pollInterval = 1000; 
+
+                    while (true) {
+                        if (Date.now() - startTime > timeout) {
+                            throw new Error(`Transaction receipt timeout after ${timeout}ms`);
+                        }
+
+                        const receipt = await provider.request({
+                            method: 'eth_getTransactionReceipt',
+                            params: [txHash],
+                        });
+
+                        if (receipt) {
+                            console.log('Transaction mined:', txHash);
+                            
+                            if (receipt.status === '0x0') {
+                                throw new Error('Transaction reverted');
+                            }
+
+                            get().updateBalance();
+                            return receipt as TransactionReceipt;
+                        }
+
+                        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                    }
+                } catch (error) {
+                    const err = error instanceof Error ? error : new Error('Failed to get receipt');
+                    throw err;
+                }
+            },
+
             setWagmiConfig: (wagmiConfig) => {
                 set({wagmiConfig});
             }