@tuwaio/pulsar-core 1.0.0-fix-retry-actions-alpha.3.fe1128f → 1.0.0-fix-callbacks-alpha.2.c81eb98

package/README.md

@@ -62,20 +62,12 @@ import { wagmiConfig, chains } from './path/to/your/wagmi/config';
 const pulsarStore = createPulsarStore({
   // A unique name for Zustand's persistence middleware. This will be the key in localStorage.
   name: 'my-app-pulsar-storage',
-
   // An array of adapters for different blockchain ecosystems.
   // Each adapter provides chain-specific logic.
-  adapters: [
+  adapter: [
     evmAdapter(wagmiConfig, chains),
     // ... add other adapters like solanaAdapter here
   ],
-
-  // (Optional) A callback function to execute on every successful transaction.
-  // Ideal for global logic like showing a success notification.
-  onSucceedCallbacks: (tx) => {
-    console.log('Transaction succeeded!', tx);
-    // e.g., showToast('Success!', { type: 'success' });
-  },
 });
 
 export default pulsarStore;

package/dist/index.d.mts

@@ -25,6 +25,20 @@ declare enum TransactionAdapter {
     /** For the Starknet L2 network. */
     Starknet = "starknet"
 }
+/**
+ * Enum representing the different tracking strategies available for EVM transactions.
+ * Each tracker corresponds to a specific method of monitoring a transaction's lifecycle.
+ */
+declare enum TransactionTracker {
+    /** For standard on-chain EVM transactions tracked by their hash. */
+    Ethereum = "ethereum",
+    /** For multi-signature transactions managed and executed via a Safe contract. */
+    Safe = "safe",
+    /** For meta-transactions relayed and executed by the Gelato Network. */
+    Gelato = "gelato",
+    /** The tracker for monitoring standard Solana transaction signatures. */
+    Solana = "solana"
+}
 /**
  * Represents the terminal status of a transaction after it has been processed.
  */
@@ -36,12 +50,30 @@ declare enum TransactionStatus {
     /** The transaction was replaced by another with the same nonce (e.g., a speed-up or cancel). */
     Replaced = "Replaced"
 }
+/**
+ * Defines the shape of the identifier for a Gelato transaction task.
+ */
+type GelatoTxKey = {
+    taskId: string;
+};
+/**
+ * A union type representing the unique identifier returned by an `actionFunction`
+ * after a transaction is submitted to the network or a relay service.
+ *
+ * This key is crucial for the EVM adapter to determine which tracker should
+ * monitor the transaction.
+ *
+ * It can be one of the following:
+ * - A standard `0x...` transaction hash (`Hex`).
+ * - A structured object from a relay service like Gelato (`GelatoTxKey`).
+ */
+type ActionTxKey = `0x${string}` | GelatoTxKey | string;
+type OnSuccessCallback<T> = (tx: T) => Promise<void> | void;
 /**
  * The fundamental structure for any transaction being tracked by Pulsar.
  * This serves as the base upon which chain-specific transaction types are built.
- * @template T The type of the tracker identifier (e.g., 'ethereum', 'gelato').
  */
-type BaseTransaction<T> = {
+type BaseTransaction = {
     /** The chain identifier (e.g., 1 for Ethereum Mainnet, 'SN_MAIN' for Starknet). */
     chainId: number | string;
     /**
@@ -81,7 +113,7 @@ type BaseTransaction<T> = {
      */
     title?: string | [string, string, string, string];
     /** The specific tracker responsible for monitoring this transaction's status. */
-    tracker: T;
+    tracker: TransactionTracker;
     /** The unique identifier for the transaction (e.g., EVM hash, Gelato task ID). */
     txKey: string;
     /** The application-specific type or category of the transaction (e.g., 'SWAP', 'APPROVE'). */
@@ -91,9 +123,8 @@ type BaseTransaction<T> = {
 };
 /**
  * Represents an EVM-specific transaction, extending the base properties with EVM fields.
- * @template T The type of the tracker identifier.
  */
-type EvmTransaction<T> = BaseTransaction<T> & {
+type EvmTransaction = BaseTransaction & {
     adapter: TransactionAdapter.EVM;
     /** The on-chain transaction hash, available after submission. */
     hash?: `0x${string}`;
@@ -114,9 +145,8 @@ type EvmTransaction<T> = BaseTransaction<T> & {
 };
 /**
  * Represents a Solana-specific transaction, extending the base properties.
- * @template T The type of the tracker identifier.
  */
-type SolanaTransaction<T> = BaseTransaction<T> & {
+type SolanaTransaction = BaseTransaction & {
     adapter: TransactionAdapter.SOLANA;
     /** The transaction fee in lamports. */
     fee?: number;
@@ -126,16 +156,15 @@ type SolanaTransaction<T> = BaseTransaction<T> & {
     recentBlockhash?: string;
     /** The slot in which the transaction was processed. */
     slot?: number;
-    /** The number of confirmations received. `null` if the transaction is pending or unconfirmed. */
-    confirmations?: number | null;
+    /** The number of confirmations received. `string` when tx successed. `null` if the transaction is pending or unconfirmed. */
+    confirmations?: number | string | null;
     /** The RPC URL used to submit and track this transaction. */
     rpcUrl?: string;
 };
 /**
  * Represents a Starknet-specific transaction, extending the base properties.
- * @template T The type of the tracker identifier.
  */
-type StarknetTransaction<T> = BaseTransaction<T> & {
+type StarknetTransaction = BaseTransaction & {
     adapter: TransactionAdapter.Starknet;
     /** The actual fee paid for the transaction. */
     actualFee?: {
@@ -144,18 +173,16 @@ type StarknetTransaction<T> = BaseTransaction<T> & {
     };
     /** The address of the contract being interacted with. */
     contractAddress?: string;
-    /** The reason for transaction failure, if applicable. */
-    revertReason?: string;
 };
 /** A union type representing any possible transaction structure that Pulsar can handle. */
-type Transaction<T> = EvmTransaction<T> | SolanaTransaction<T> | StarknetTransaction<T>;
+type Transaction = EvmTransaction | SolanaTransaction | StarknetTransaction;
 /**
  * Represents the parameters required to initiate a new transaction tracking flow.
  */
-type InitialTransactionParams<A> = {
+type InitialTransactionParams = {
     adapter: TransactionAdapter;
     /** The function that executes the on-chain action (e.g., sending a transaction) and returns a preliminary identifier like a hash. */
-    actionFunction: (...args: any[]) => Promise<A | undefined>;
+    actionFunction: (...args: any[]) => Promise<ActionTxKey | undefined>;
     /** A user-facing description for the transaction. Supports state-specific descriptions. */
     description?: string | [string, string, string, string];
     /** The target chain ID for the transaction. */
@@ -175,7 +202,7 @@ type InitialTransactionParams<A> = {
  * Represents a transaction in its temporary, pre-submission state.
  * This is used for UI feedback while the transaction is being signed and sent.
  */
-type InitialTransaction<A> = InitialTransactionParams<A> & {
+type InitialTransaction = InitialTransactionParams & {
     /** An error message if the initialization fails (e.g., user rejects signature). */
     errorMessage?: string;
     /** A flag indicating if the transaction is being processed (e.g., waiting for signature). */
@@ -187,11 +214,9 @@ type InitialTransaction<A> = InitialTransactionParams<A> & {
 };
 /**
  * Defines the interface for a transaction adapter, which provides chain-specific logic and utilities.
- * @template TR The type of the tracker identifier (e.g., a string enum).
- * @template T The specific transaction type, extending `Transaction<TR>`.
- * @template A The type of the key returned by the `actionFunction` (e.g., a transaction hash).
+ * @template T The specific transaction type, extending `Transaction`.
  */
-type TxAdapter<TR, T extends Transaction<TR>, A> = {
+type TxAdapter<T extends Transaction> = {
     /** The unique key identifying this adapter. */
     key: TransactionAdapter;
     /** Returns information about the currently connected wallet. */
@@ -202,16 +227,17 @@ type TxAdapter<TR, T extends Transaction<TR>, A> = {
     /** Ensures the connected wallet is on the correct network for the transaction. Throws an error if the chain is mismatched. */
     checkChainForTx: (chainId: string | number) => Promise<void>;
     /** Determines the appropriate tracker and final `txKey` from the result of an action. */
-    checkTransactionsTracker: (actionTxKey: A, walletType: string) => {
+    checkTransactionsTracker: (actionTxKey: ActionTxKey, walletType: string) => {
         txKey: string;
-        tracker: TR;
+        tracker: TransactionTracker;
     };
     /** Selects and initializes the correct background tracker for a given transaction. */
     checkAndInitializeTrackerInStore: (params: {
         tx: T;
-    } & Pick<ITxTrackingStore<TR, T, A>, 'transactionsPool' | 'updateTxParams' | 'onSucceedCallbacks' | 'removeTxFromPool'>) => Promise<void>;
+        onSucceedCallback?: OnSuccessCallback<T>;
+    } & Pick<ITxTrackingStore<T>, 'updateTxParams' | 'removeTxFromPool' | 'transactionsPool'>) => Promise<void>;
     /** Returns the base URL for the blockchain explorer for the current network. */
-    getExplorerUrl: () => string | undefined;
+    getExplorerUrl: (url?: string) => string | undefined;
     /** Optional: Fetches a name from a chain-specific name service (e.g., ENS). */
     getName?: (address: string) => Promise<string | null>;
     /** Optional: Fetches an avatar URL from a chain-specific name service. */
@@ -223,22 +249,20 @@ type TxAdapter<TR, T extends Transaction<TR>, A> = {
     /** Optional: Logic to retry a failed transaction. */
     retryTxAction?: (params: {
         txKey: string;
-        tx: InitialTransactionParams<A>;
+        tx: InitialTransactionParams;
         onClose: (txKey?: string) => void;
-    } & Partial<Pick<ITxTrackingStore<TR, T, A>, 'handleTransaction'>>) => Promise<void>;
+    } & Partial<Pick<ITxTrackingStore<T>, 'handleTransaction'>>) => Promise<void>;
     /**
      * Optional: Constructs a full explorer URL for a specific transaction.
      * May require the full transaction pool to resolve details for replaced transactions.
      */
-    getExplorerTxUrl?: (transactionsPool: TransactionPool<TR, T>, txKey: string, replacedTxHash?: string) => string;
+    getExplorerTxUrl?: (tx: T) => string;
 };
 /**
  * The complete interface for the Pulsar transaction tracking store.
- * @template TR The type of the tracker identifier.
  * @template T The transaction type.
- * @template A The return type of the `actionFunction`.
  */
-type ITxTrackingStore<TR, T extends Transaction<TR>, A> = IInitializeTxTrackingStore<TR, T, A> & {
+type ITxTrackingStore<T extends Transaction> = IInitializeTxTrackingStore<T> & {
     /**
      * The primary method for initiating and tracking a new transaction from start to finish.
      * It manages UI state, executes the on-chain action, and initiates background tracking.
@@ -246,11 +270,13 @@ type ITxTrackingStore<TR, T extends Transaction<TR>, A> = IInitializeTxTrackingS
      */
     handleTransaction: (params: {
         /** The async function to execute (e.g., a smart contract write call). Must return a unique key or undefined. */
-        actionFunction: () => Promise<A | undefined>;
+        actionFunction: () => Promise<ActionTxKey | undefined>;
         /** The metadata for the transaction. */
-        params: Omit<InitialTransactionParams<A>, 'actionFunction'>;
+        params: Omit<InitialTransactionParams, 'actionFunction'>;
         /** The default tracker to use if it cannot be determined automatically. */
-        defaultTracker?: TR;
+        defaultTracker?: TransactionTracker;
+        /** Callback to execute when the transaction is successfully submitted. */
+        onSucceedCallback?: OnSuccessCallback<T>;
     }) => Promise<void>;
     /**
      * Initializes trackers for all pending transactions in the pool.
@@ -266,37 +292,31 @@ type ITxTrackingStore<TR, T extends Transaction<TR>, A> = IInitializeTxTrackingS
 
 /**
  * Defines the structure of the transaction pool, a key-value store of transactions indexed by their unique keys.
- * @template TR The type of the tracker identifier.
- * @template T The transaction type.
+ * @template T The type of the transaction object being tracked.
  */
-type TransactionPool<TR, T extends Transaction<TR>> = Record<string, T>;
+type TransactionPool<T extends Transaction> = Record<string, T>;
 /**
  * A utility type that creates a union of all fields that can be safely updated
  * on a transaction object via the `updateTxParams` action. This ensures type safety
  * and prevents accidental modification of immutable properties.
- * @template TR The type of the tracker identifier.
  */
-type UpdatableTransactionFields<TR> = Partial<Pick<EvmTransaction<TR>, 'to' | 'nonce' | 'txKey' | 'pending' | 'hash' | 'status' | 'replacedTxHash' | 'errorMessage' | 'finishedTimestamp' | 'isTrackedModalOpen' | 'isError' | 'maxPriorityFeePerGas' | 'maxFeePerGas' | 'input' | 'value'>> & Partial<Pick<SolanaTransaction<TR>, 'slot' | 'confirmations' | 'fee' | 'instructions' | 'recentBlockhash' | 'rpcUrl'>>;
+type UpdatableTransactionFields = Partial<Pick<EvmTransaction, 'to' | 'nonce' | 'txKey' | 'pending' | 'hash' | 'status' | 'replacedTxHash' | 'errorMessage' | 'finishedTimestamp' | 'isTrackedModalOpen' | 'isError' | 'maxPriorityFeePerGas' | 'maxFeePerGas' | 'input' | 'value'>> & Partial<Pick<SolanaTransaction, 'slot' | 'confirmations' | 'fee' | 'instructions' | 'recentBlockhash' | 'rpcUrl'>>;
 /**
  * The interface for the base transaction tracking store slice.
  * It includes the state and actions for managing the transaction lifecycle.
- * @template TR The type of the tracker identifier.
  * @template T The specific transaction type.
- * @template A The return type of the initial action function.
  */
-interface IInitializeTxTrackingStore<TR, T extends Transaction<TR>, A> {
-    /** A callback function executed when any transaction successfully completes. */
-    onSucceedCallbacks?: (tx: T) => Promise<void> | void;
+interface IInitializeTxTrackingStore<T extends Transaction> {
     /** A pool of all transactions currently being tracked, indexed by `txKey`. */
-    transactionsPool: TransactionPool<TR, T>;
+    transactionsPool: TransactionPool<T>;
     /** The `txKey` of the most recently added transaction. */
     lastAddedTxKey?: string;
     /** The state for a transaction being initiated, used for UI feedback before it's submitted to the chain. */
-    initialTx?: InitialTransaction<A>;
+    initialTx?: InitialTransaction;
     /** Adds a new transaction to the tracking pool and marks it as pending. */
-    addTxToPool: (tx: Transaction<TR>) => void;
+    addTxToPool: (tx: T) => void;
     /** Updates one or more properties of an existing transaction in the pool. */
-    updateTxParams: (txKey: string, fields: UpdatableTransactionFields<TR>) => void;
+    updateTxParams: (txKey: string, fields: UpdatableTransactionFields) => void;
     /** Removes a transaction from the tracking pool by its key. */
     removeTxFromPool: (txKey: string) => void;
     /** Closes the tracking modal for a transaction and clears any initial transaction state. */
@@ -308,16 +328,11 @@ interface IInitializeTxTrackingStore<TR, T extends Transaction<TR>, A> {
  * Creates a Zustand store slice with the core logic for transaction state management.
  * This function is a slice creator intended for use with Zustand's `create` function.
  *
- * @template TR The type of the tracker identifier.
  * @template T The specific transaction type.
- * @template A The return type of the initial action function.
  * @param options Configuration for the store slice.
- * @param options.onSucceedCallbacks An optional async callback to run when a transaction succeeds.
  * @returns A Zustand store slice implementing `IInitializeTxTrackingStore`.
  */
-declare function initializeTxTrackingStore<TR, T extends Transaction<TR>, A>({ onSucceedCallbacks, }: {
-    onSucceedCallbacks?: (tx: T) => Promise<void> | void;
-}): StoreSlice<IInitializeTxTrackingStore<TR, T, A>>;
+declare function initializeTxTrackingStore<T extends Transaction>(): StoreSlice<IInitializeTxTrackingStore<T>>;
 
 /**
  * @file This file contains selector functions for deriving state from the transaction tracking store.
@@ -326,47 +341,42 @@ declare function initializeTxTrackingStore<TR, T extends Transaction<TR>, A>({ o
 
 /**
  * Selects all transactions from the pool and sorts them by their creation timestamp in ascending order.
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type.
- * @param {TransactionPool<TR, T>} transactionsPool - The entire transaction pool from the store.
+ * @param {TransactionPool<T>} transactionsPool - The entire transaction pool from the store.
  * @returns {T[]} An array of all transactions, sorted chronologically.
  */
-declare const selectAllTransactions: <TR, T extends Transaction<TR>>(transactionsPool: TransactionPool<TR, T>) => T[];
+declare const selectAllTransactions: <T extends Transaction>(transactionsPool: TransactionPool<T>) => T[];
 /**
  * Selects all transactions that are currently in a pending state, sorted chronologically.
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type.
- * @param {TransactionPool<TR, T>} transactionsPool - The entire transaction pool from the store.
+ * @param {TransactionPool<T>} transactionsPool - The entire transaction pool from the store.
  * @returns {T[]} An array of pending transactions.
  */
-declare const selectPendingTransactions: <TR, T extends Transaction<TR>>(transactionsPool: TransactionPool<TR, T>) => T[];
+declare const selectPendingTransactions: <T extends Transaction>(transactionsPool: TransactionPool<T>) => T[];
 /**
  * Selects a single transaction from the pool by its unique key (`txKey`).
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type.
- * @param {TransactionPool<TR, T>} transactionsPool - The entire transaction pool from the store.
+ * @param {TransactionPool<T>} transactionsPool - The entire transaction pool from the store.
  * @param {string} key - The `txKey` of the transaction to retrieve.
  * @returns {T | undefined} The transaction object if found, otherwise undefined.
  */
-declare const selectTxByKey: <TR, T extends Transaction<TR>>(transactionsPool: TransactionPool<TR, T>, key: string) => T | undefined;
+declare const selectTxByKey: <T extends Transaction>(transactionsPool: TransactionPool<T>, key: string) => T | undefined;
 /**
  * Selects all transactions initiated by a specific wallet address, sorted chronologically.
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type.
- * @param {TransactionPool<TR, T>} transactionsPool - The entire transaction pool from the store.
+ * @param {TransactionPool<T>} transactionsPool - The entire transaction pool from the store.
  * @param {string} from - The wallet address (`from` address) to filter transactions by.
  * @returns {T[]} An array of transactions associated with the given wallet.
  */
-declare const selectAllTransactionsByActiveWallet: <TR, T extends Transaction<TR>>(transactionsPool: TransactionPool<TR, T>, from: string) => T[];
+declare const selectAllTransactionsByActiveWallet: <T extends Transaction>(transactionsPool: TransactionPool<T>, from: string) => T[];
 /**
  * Selects all pending transactions for a specific wallet address, sorted chronologically.
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type.
- * @param {TransactionPool<TR, T>} transactionsPool - The entire transaction pool from the store.
+ * @param {TransactionPool<T>} transactionsPool - The entire transaction pool from the store.
  * @param {string} from - The wallet address (`from` address) to filter transactions by.
  * @returns {T[]} An array of pending transactions for the given wallet.
  */
-declare const selectPendingTransactionsByActiveWallet: <TR, T extends Transaction<TR>>(transactionsPool: TransactionPool<TR, T>, from: string) => T[];
+declare const selectPendingTransactionsByActiveWallet: <T extends Transaction>(transactionsPool: TransactionPool<T>, from: string) => T[];
 
 /**
  * Creates the main Pulsar store for transaction tracking.
@@ -375,30 +385,26 @@ declare const selectPendingTransactionsByActiveWallet: <TR, T extends Transactio
  * slice with a powerful orchestration logic that leverages chain-specific adapters to handle the entire
  * lifecycle of a transaction—from initiation and chain validation to execution and background status tracking.
  *
- * @template TR The type of the tracker identifier (e.g., a string enum).
  * @template T The specific transaction type, extending the base `Transaction`.
- * @template A The type of the key returned by the `actionFunction` (e.g., a transaction hash).
  *
  * @param config Configuration object for creating the store.
- * @param config.onSucceedCallbacks Optional async callback executed on transaction success.
- * @param config.adapters An array of adapters for different chains or transaction types.
+ * @param config.adapter Adapter or an array of adapters for different chains or transaction types.
  * @param options Configuration for the Zustand `persist` middleware.
  * @returns A fully configured Zustand store instance.
  */
-declare function createPulsarStore<TR, T extends Transaction<TR>, A>({ onSucceedCallbacks, adapters, ...options }: {
-    onSucceedCallbacks?: (tx: T) => Promise<void> | void;
-    adapters: TxAdapter<TR, T, A>[];
-} & PersistOptions<ITxTrackingStore<TR, T, A>>): Omit<zustand.StoreApi<ITxTrackingStore<TR, T, A>>, "setState" | "persist"> & {
-    setState(partial: ITxTrackingStore<TR, T, A> | Partial<ITxTrackingStore<TR, T, A>> | ((state: ITxTrackingStore<TR, T, A>) => ITxTrackingStore<TR, T, A> | Partial<ITxTrackingStore<TR, T, A>>), replace?: false | undefined): unknown;
-    setState(state: ITxTrackingStore<TR, T, A> | ((state: ITxTrackingStore<TR, T, A>) => ITxTrackingStore<TR, T, A>), replace: true): unknown;
+declare function createPulsarStore<T extends Transaction>({ adapter, ...options }: {
+    adapter: TxAdapter<T> | TxAdapter<T>[];
+} & PersistOptions<ITxTrackingStore<T>>): Omit<zustand.StoreApi<ITxTrackingStore<T>>, "setState" | "persist"> & {
+    setState(partial: ITxTrackingStore<T> | Partial<ITxTrackingStore<T>> | ((state: ITxTrackingStore<T>) => ITxTrackingStore<T> | Partial<ITxTrackingStore<T>>), replace?: false | undefined): unknown;
+    setState(state: ITxTrackingStore<T> | ((state: ITxTrackingStore<T>) => ITxTrackingStore<T>), replace: true): unknown;
     persist: {
-        setOptions: (options: Partial<PersistOptions<ITxTrackingStore<TR, T, A>, ITxTrackingStore<TR, T, A>, unknown>>) => void;
+        setOptions: (options: Partial<PersistOptions<ITxTrackingStore<T>, ITxTrackingStore<T>, unknown>>) => void;
         clearStorage: () => void;
         rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
-        onHydrate: (fn: (state: ITxTrackingStore<TR, T, A>) => void) => () => void;
-        onFinishHydration: (fn: (state: ITxTrackingStore<TR, T, A>) => void) => () => void;
-        getOptions: () => Partial<PersistOptions<ITxTrackingStore<TR, T, A>, ITxTrackingStore<TR, T, A>, unknown>>;
+        onHydrate: (fn: (state: ITxTrackingStore<T>) => void) => () => void;
+        onFinishHydration: (fn: (state: ITxTrackingStore<T>) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<ITxTrackingStore<T>, ITxTrackingStore<T>, unknown>>;
     };
 };
 
@@ -447,8 +453,8 @@ declare const createBoundedUseStore: <S extends StoreApi<unknown>>(store: S) =>
 /**
  * Defines the parameters for the fetcher function used within the polling tracker.
  * The fetcher is the core logic that performs the actual API call.
- * @template R - The expected type of the successful API response.
- * @template T - The type of the transaction object being tracked.
+ * @template R The expected type of the successful API response.
+ * @template T The type of the transaction object being tracked.
  */
 type PollingFetcherParams<R, T> = {
     /** The transaction object being tracked. */
@@ -468,13 +474,12 @@ type PollingFetcherParams<R, T> = {
 };
 /**
  * Defines the configuration object for the `initializePollingTracker` function.
- * @template R - The expected type of the successful API response.
- * @template T - The type of the transaction object.
- * @template TR - The type of the tracker identifier.
+ * @template R The expected type of the successful API response.
+ * @template T The type of the transaction object.
  */
-type PollingTrackerConfig<R, T, TR> = {
+type PollingTrackerConfig<R, T extends Transaction> = {
     /** The transaction object to be tracked. It must include `txKey` and `pending` status. */
-    tx: T & Pick<Transaction<TR>, 'txKey' | 'pending'>;
+    tx: T & Pick<Transaction, 'txKey' | 'pending'>;
     /** The function that performs the data fetching (e.g., an API call) on each interval. */
     fetcher: (params: PollingFetcherParams<R, T>) => Promise<void>;
     /** Callback to be invoked when the transaction successfully completes. */
@@ -503,10 +508,9 @@ type PollingTrackerConfig<R, T, TR> = {
  *
  * @template R The expected type of the API response.
  * @template T The type of the transaction object.
- * @template TR The type of the tracker identifier.
- * @param {PollingTrackerConfig<R, T, TR>} config - The configuration for the tracker.
+ * @param {PollingTrackerConfig<R, T>} config - The configuration for the tracker.
  */
-declare function initializePollingTracker<R, T, TR>(config: PollingTrackerConfig<R, T, TR>): void;
+declare function initializePollingTracker<R, T extends Transaction>(config: PollingTrackerConfig<R, T>): void;
 
 /**
  * @file This file contains a utility function for selecting a specific transaction adapter from a list.
@@ -520,19 +524,17 @@ declare function initializePollingTracker<R, T, TR>(config: PollingTrackerConfig
  * and returns the first adapter in the array as a fallback. This fallback mechanism
  * ensures that the system can still function, but it highlights a potential configuration issue.
  *
- * @template TR - The type of the tracker identifier.
  * @template T - The transaction type, extending the base `Transaction`.
- * @template A - The type for the adapter-specific context or API.
  *
  * @param {object} params - The parameters for the selection.
  * @param {TransactionAdapter} params.adapterKey - The key of the desired adapter.
- * @param {TxAdapter<TR, T, A>[]} params.adapters - An array of available transaction adapters.
+ * @param {TxAdapter<T> | TxAdapter<T>[]} params.adapter - Adapter or an array of adapters for different chains or transaction types.
  *
- * @returns {TxAdapter<TR, T, A> | undefined} The found transaction adapter, the fallback adapter, or undefined if the adapters array is empty.
+ * @returns {TxAdapter<T> | undefined} The found transaction adapter, the fallback adapter, or undefined if the adapters array is empty.
  */
-declare const selectAdapterByKey: <TR, T extends Transaction<TR>, A>({ adapterKey, adapters, }: {
+declare const selectAdapterByKey: <T extends Transaction>({ adapterKey, adapter, }: {
     adapterKey: TransactionAdapter;
-    adapters: TxAdapter<TR, T, A>[];
-}) => TxAdapter<TR, T, A> | undefined;
+    adapter: TxAdapter<T> | TxAdapter<T>[];
+}) => TxAdapter<T> | undefined;
 
-export { type BaseTransaction, type EvmTransaction, type IInitializeTxTrackingStore, type ITxTrackingStore, type InitialTransaction, type InitialTransactionParams, type PollingTrackerConfig, type SolanaTransaction, type StarknetTransaction, type StoreSlice, type Transaction, TransactionAdapter, type TransactionPool, TransactionStatus, type TxAdapter, createBoundedUseStore, createPulsarStore, initializePollingTracker, initializeTxTrackingStore, selectAdapterByKey, selectAllTransactions, selectAllTransactionsByActiveWallet, selectPendingTransactions, selectPendingTransactionsByActiveWallet, selectTxByKey };
+export { type ActionTxKey, type BaseTransaction, type EvmTransaction, type GelatoTxKey, type IInitializeTxTrackingStore, type ITxTrackingStore, type InitialTransaction, type InitialTransactionParams, type OnSuccessCallback, type PollingTrackerConfig, type SolanaTransaction, type StarknetTransaction, type StoreSlice, type Transaction, TransactionAdapter, type TransactionPool, TransactionStatus, TransactionTracker, type TxAdapter, createBoundedUseStore, createPulsarStore, initializePollingTracker, initializeTxTrackingStore, selectAdapterByKey, selectAllTransactions, selectAllTransactionsByActiveWallet, selectPendingTransactions, selectPendingTransactionsByActiveWallet, selectTxByKey };