@explorins/pers-sdk-react-native 2.1.5 → 2.1.6

package/dist/hooks/useEvents.d.ts

@@ -24,23 +24,35 @@ export interface EventsHook {
  * React Native hook for PERS SDK event system
  *
  * This hook provides access to the platform-agnostic event system for subscribing to
- * transaction, authentication, campaign, and system events. All events include a
- * `userMessage` field ready for display to end users.
+ * transaction, authentication, campaign, blockchain, and system events. All events
+ * include a `userMessage` field ready for display to end users.
  *
  * **Event Domains:**
  * - `auth` - Authentication events (login, logout, token refresh)
  * - `user` - User profile events (update, create)
- * - `transaction` - Transaction events (created, completed, failed)
+ * - `transaction` - Transaction events (created, submitted, confirmed)
  * - `campaign` - Campaign events (claimed, activated)
  * - `redemption` - Redemption events (redeemed, expired)
  * - `business` - Business events (created, updated, membership)
+ * - `wallet` - Real-time blockchain events (Transfer, Approval, etc.) - Auto-enabled on auth
  * - `api` - API error events (network, validation, server errors)
  *
+ * **Blockchain Events (Wallet Domain):**
+ * When `sdk.connectWalletEvents()` is called (or auto-enabled via `captureWalletEvents: true`),
+ * real-time blockchain events are automatically routed through the same event system:
+ * ```typescript
+ * const { subscribe } = useEvents();
+ *
+ * subscribe((event) => {
+ *   if (event.domain === 'wallet') {
+ *     console.log('Blockchain event:', event.type); // wallet_transfer, wallet_approval, etc.
+ *   }
+ * });
+ * ```
+ *
  * **Notification Levels:**
  * - `success` - Operation completed successfully
  * - `error` - Operation failed
- * - `warning` - Operation completed with warnings
- * - `info` - Informational event
  *
  * **Cleanup:**
  * All subscriptions created through this hook are automatically cleaned up when

package/dist/hooks/useEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEvents.d.ts","sourceRoot":"","sources":["../../src/hooks/useEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACxE,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACnE,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwJG;AACH,eAAO,MAAM,SAAS,QAAO,UA2K5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}
+{"version":3,"file":"useEvents.d.ts","sourceRoot":"","sources":["../../src/hooks/useEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACxE,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACnE,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoKG;AACH,eAAO,MAAM,SAAS,QAAO,UA2K5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/hooks/useEvents.js

@@ -4,23 +4,35 @@ import { usePersSDK } from '../providers/PersSDKProvider';
  * React Native hook for PERS SDK event system
  *
  * This hook provides access to the platform-agnostic event system for subscribing to
- * transaction, authentication, campaign, and system events. All events include a
- * `userMessage` field ready for display to end users.
+ * transaction, authentication, campaign, blockchain, and system events. All events
+ * include a `userMessage` field ready for display to end users.
  *
  * **Event Domains:**
  * - `auth` - Authentication events (login, logout, token refresh)
  * - `user` - User profile events (update, create)
- * - `transaction` - Transaction events (created, completed, failed)
+ * - `transaction` - Transaction events (created, submitted, confirmed)
  * - `campaign` - Campaign events (claimed, activated)
  * - `redemption` - Redemption events (redeemed, expired)
  * - `business` - Business events (created, updated, membership)
+ * - `wallet` - Real-time blockchain events (Transfer, Approval, etc.) - Auto-enabled on auth
  * - `api` - API error events (network, validation, server errors)
  *
+ * **Blockchain Events (Wallet Domain):**
+ * When `sdk.connectWalletEvents()` is called (or auto-enabled via `captureWalletEvents: true`),
+ * real-time blockchain events are automatically routed through the same event system:
+ * ```typescript
+ * const { subscribe } = useEvents();
+ *
+ * subscribe((event) => {
+ *   if (event.domain === 'wallet') {
+ *     console.log('Blockchain event:', event.type); // wallet_transfer, wallet_approval, etc.
+ *   }
+ * });
+ * ```
+ *
  * **Notification Levels:**
  * - `success` - Operation completed successfully
  * - `error` - Operation failed
- * - `warning` - Operation completed with warnings
- * - `info` - Informational event
  *
  * **Cleanup:**
  * All subscriptions created through this hook are automatically cleaned up when

package/dist/hooks/useTokenBalances.d.ts

@@ -31,6 +31,18 @@ export interface UseTokenBalancesOptions {
     autoLoad?: boolean;
     /** Optional refresh interval in milliseconds (0 = disabled) */
     refreshInterval?: number;
+    /**
+     * Auto-refresh balances when wallet events are received (Transfer, Approval, etc.)
+     * Requires `captureWalletEvents: true` in SDK config (default)
+     * @default true
+     */
+    refreshOnWalletEvents?: boolean;
+    /**
+     * Debounce time for wallet event-triggered refreshes (milliseconds)
+     * Prevents rapid refresh calls during batch transfers
+     * @default 1000
+     */
+    walletEventDebounceMs?: number;
 }
 /**
  * Token balance loading hook return value
@@ -119,6 +131,18 @@ export interface UseTokenBalancesResult {
  * ```
  *
  * @example
+ * **With Wallet Events (Real-time):**
+ * ```typescript
+ * // Auto-refresh on Transfer, Approval, and other blockchain events
+ * const { tokenBalances } = useTokenBalances({
+ *   accountAddress: walletAddress!,
+ *   availableTokens,
+ *   refreshOnWalletEvents: true,    // Enable real-time refresh (default: true)
+ *   walletEventDebounceMs: 1000     // Debounce rapid events (default: 1000ms)
+ * });
+ * ```
+ *
+ * @example
  * **Multi-Wallet Support:**
  * ```typescript
  * function MultiWalletBalances() {

package/dist/hooks/useTokenBalances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTokenBalances.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokenBalances.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,YAAY,EAAE,YAAY,CAAC;IAC3B,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC;IAChB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,sFAAsF;IACtF,WAAW,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CA8JzF"}
+{"version":3,"file":"useTokenBalances.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokenBalances.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,0BAA0B,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,YAAY,EAAE,YAAY,CAAC;IAC3B,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC;IAChB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,sFAAsF;IACtF,WAAW,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CAgMzF"}

package/dist/hooks/useTokenBalances.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useState, useRef } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
 import { useWeb3 } from './useWeb3';
 import { NativeTokenTypes } from '@explorins/pers-shared';
@@ -72,6 +72,18 @@ import { NativeTokenTypes } from '@explorins/pers-shared';
  * ```
  *
  * @example
+ * **With Wallet Events (Real-time):**
+ * ```typescript
+ * // Auto-refresh on Transfer, Approval, and other blockchain events
+ * const { tokenBalances } = useTokenBalances({
+ *   accountAddress: walletAddress!,
+ *   availableTokens,
+ *   refreshOnWalletEvents: true,    // Enable real-time refresh (default: true)
+ *   walletEventDebounceMs: 1000     // Debounce rapid events (default: 1000ms)
+ * });
+ * ```
+ *
+ * @example
  * **Multi-Wallet Support:**
  * ```typescript
  * function MultiWalletBalances() {
@@ -90,12 +102,14 @@ import { NativeTokenTypes } from '@explorins/pers-shared';
  * ```
  */
 export function useTokenBalances(options) {
-    const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0 } = options;
+    const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0, refreshOnWalletEvents = true, walletEventDebounceMs = 1000 } = options;
     const { isAuthenticated, sdk } = usePersSDK();
     const web3 = useWeb3();
     const [tokenBalances, setTokenBalances] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
+    // Debounce ref for wallet events
+    const walletEventDebounceRef = useRef(null);
     // Check if the hook is available for use
     const isAvailable = web3.isAvailable && isAuthenticated && !!accountAddress;
     /**
@@ -215,6 +229,32 @@ export function useTokenBalances(options) {
             clearInterval(intervalId);
         };
     }, [sdk, refreshInterval, isAvailable, loadBalances]);
+    // Wallet events refresh: listen for real-time blockchain events
+    // Refreshes on ANY wallet domain event (Transfer, TransferSingle, etc.)
+    // Debouncing prevents excessive API calls during rapid events
+    useEffect(() => {
+        if (!sdk || !refreshOnWalletEvents || !isAvailable)
+            return;
+        const unsubscribe = sdk.events.subscribe((event) => {
+            if (event.domain === 'wallet') {
+                // Debounce rapid events (batch transfers, etc.)
+                if (walletEventDebounceRef.current) {
+                    clearTimeout(walletEventDebounceRef.current);
+                }
+                walletEventDebounceRef.current = setTimeout(() => {
+                    console.log(`[useTokenBalances] Wallet event (${event.type}), refreshing balances...`);
+                    loadBalances();
+                    walletEventDebounceRef.current = null;
+                }, walletEventDebounceMs);
+            }
+        }, { domains: ['wallet'] });
+        return () => {
+            unsubscribe();
+            if (walletEventDebounceRef.current) {
+                clearTimeout(walletEventDebounceRef.current);
+            }
+        };
+    }, [sdk, refreshOnWalletEvents, walletEventDebounceMs, isAvailable, loadBalances]);
     return {
         tokenBalances,
         isLoading,

package/dist/hooks/useUsers.d.ts

@@ -1,16 +1,17 @@
 import type { UserDTO, UserCreateRequestDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
-import type { UserPublicProfileDTO } from '@explorins/pers-sdk/user';
+import type { UserPublicProfileDTO, UserQueryOptions } from '@explorins/pers-sdk/user';
+export type { UserQueryOptions } from '@explorins/pers-sdk/user';
 export declare const useUsers: () => {
-    getCurrentUser: () => Promise<UserDTO>;
+    getCurrentUser: (options?: UserQueryOptions) => Promise<UserDTO>;
     updateCurrentUser: (userData: UserCreateRequestDTO) => Promise<UserDTO>;
-    getUserById: (userId: string) => Promise<UserDTO>;
+    getUserById: (userId: string, options?: UserQueryOptions) => Promise<UserDTO>;
     getAllUsersPublic: (filter?: {
         key: string;
         value: string;
     }) => Promise<PaginatedResponseDTO<UserPublicProfileDTO>>;
     getAllUsers: () => Promise<PaginatedResponseDTO<UserDTO>>;
     updateUser: (userId: string, userData: UserCreateRequestDTO) => Promise<UserDTO>;
-    toggleUserStatus: (user: UserDTO) => Promise<UserDTO>;
+    setUserActiveStatus: (userId: string, isActive?: boolean) => Promise<UserDTO>;
     isAvailable: boolean;
 };
 export type UserHook = ReturnType<typeof useUsers>;

package/dist/hooks/useUsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUsers.d.ts","sourceRoot":"","sources":["../../src/hooks/useUsers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,eAAO,MAAM,QAAQ;0BAG0B,QAAQ,OAAO,CAAC;kCAiBN,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAiB/C,MAAM,KAAG,QAAQ,OAAO,CAAC;iCAclB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,qBAAqB,oBAAoB,CAAC,CAAC;uBAehG,QAAQ,qBAAqB,OAAO,CAAC,CAAC;yBAclC,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;6BAcrD,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAwB7E,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"useUsers.d.ts","sourceRoot":"","sources":["../../src/hooks/useUsers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGvF,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,eAAO,MAAM,QAAQ;+BAmBiC,gBAAgB,KAAG,QAAQ,OAAO,CAAC;kCAiBhC,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAiC/C,MAAM,YAAY,gBAAgB,KAAG,QAAQ,OAAO,CAAC;iCAc9C;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,qBAAqB,oBAAoB,CAAC,CAAC;uBAehG,QAAQ,qBAAqB,OAAO,CAAC,CAAC;yBAclC,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;kCAqBhD,MAAM,aAAa,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAwBrG,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/hooks/useUsers.js

@@ -2,7 +2,23 @@ import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
 export const useUsers = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
-    const getCurrentUser = useCallback(async () => {
+    /**
+     * Get the current authenticated user with optional include relations
+     *
+     * @param options - Query options including include relations
+     * @returns Current user data
+     *
+     * @example
+     * ```typescript
+     * // Basic
+     * const user = await getCurrentUser();
+     *
+     * // With wallets included
+     * const userWithWallets = await getCurrentUser({ include: ['wallets'] });
+     * console.log('Wallets:', userWithWallets.included?.wallets);
+     * ```
+     */
+    const getCurrentUser = useCallback(async (options) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -10,7 +26,7 @@ export const useUsers = () => {
             throw new Error('SDK not authenticated. getCurrentUser requires authentication.');
         }
         try {
-            const result = await sdk.users.getCurrentUser();
+            const result = await sdk.users.getCurrentUser(options);
             return result;
         }
         catch (error) {
@@ -34,12 +50,28 @@ export const useUsers = () => {
             throw error;
         }
     }, [sdk, isInitialized, isAuthenticated]);
-    const getUserById = useCallback(async (userId) => {
+    /**
+     * Get user by ID with optional include relations
+     *
+     * @param userId - User identifier (id, email, externalId, etc.)
+     * @param options - Query options including include relations
+     * @returns User data
+     *
+     * @example
+     * ```typescript
+     * // Basic
+     * const user = await getUserById('user-123');
+     *
+     * // With wallets included
+     * const userWithWallets = await getUserById('user-123', { include: ['wallets'] });
+     * ```
+     */
+    const getUserById = useCallback(async (userId, options) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.users.getUserById(userId);
+            const result = await sdk.users.getUserById(userId, options);
             return result;
         }
         catch (error) {
@@ -87,16 +119,23 @@ export const useUsers = () => {
             throw error;
         }
     }, [sdk, isInitialized]);
-    const toggleUserStatus = useCallback(async (user) => {
+    /**
+     * Toggle or set a user's active status (admin only)
+     *
+     * @param userId - User ID to update
+     * @param isActive - Optional explicit status. If omitted, toggles current status.
+     * @returns Updated user
+     */
+    const setUserActiveStatus = useCallback(async (userId, isActive) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.users.toggleUserStatus(user);
+            const result = await sdk.users.setUserActiveStatus(userId, isActive);
             return result;
         }
         catch (error) {
-            console.error('Failed to toggle user status:', error);
+            console.error('Failed to set user active status:', error);
             throw error;
         }
     }, [sdk, isInitialized]);
@@ -107,7 +146,7 @@ export const useUsers = () => {
         getAllUsersPublic,
         getAllUsers,
         updateUser,
-        toggleUserStatus,
+        setUserActiveStatus,
         isAvailable: isInitialized && !!sdk?.users,
     };
 };

package/dist/hooks/useWeb3.d.ts

@@ -1,6 +1,7 @@
+import { Web3Manager } from '@explorins/pers-sdk/web3';
 import type { TokenBalance, TokenBalanceRequest, TokenCollectionRequest, TokenCollection, TokenMetadata, AccountOwnedTokensResult } from '@explorins/pers-sdk/web3';
-import type { ChainData } from '@explorins/pers-sdk/web3-chain';
-import type { TokenDTO } from '@explorins/pers-shared';
+import type { TokenDTO } from '@explorins/pers-sdk/token';
+type ChainData = Awaited<ReturnType<Web3Manager['getChainDataById']>>;
 export type { AccountOwnedTokensResult } from '@explorins/pers-sdk/web3';
 /**
  * React hook for Web3 operations in the PERS SDK
@@ -56,9 +57,9 @@ export declare const useWeb3: () => {
     getTokenBalance: (request: TokenBalanceRequest) => Promise<TokenBalance>;
     getTokenMetadata: (request: TokenBalanceRequest) => Promise<TokenMetadata | null>;
     getTokenCollection: (request: TokenCollectionRequest) => Promise<TokenCollection>;
-    resolveIPFSUrl: (url: string, chainId: number) => Promise<string>;
-    fetchAndProcessMetadata: (tokenUri: string, chainId: number) => Promise<TokenMetadata | null>;
-    getChainDataById: (chainId: number) => Promise<ChainData | null>;
+    resolveIPFSUrl: (url: string) => Promise<string>;
+    fetchAndProcessMetadata: (tokenUri: string) => Promise<TokenMetadata | null>;
+    getChainDataById: (chainId: number) => Promise<ChainData>;
     getExplorerUrl: (chainId: number, address: string, type: 'address' | 'tx') => Promise<string>;
     extractTokenIds: (token: TokenDTO) => string[] | undefined;
     getAccountOwnedTokensFromContract: (accountAddress: string, token: TokenDTO, maxTokens?: number) => Promise<AccountOwnedTokensResult>;

package/dist/hooks/useWeb3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWeb3.d.ts","sourceRoot":"","sources":["../../src/hooks/useWeb3.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,wBAAwB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGvD,YAAY,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,OAAO;+BAmCkC,mBAAmB,KAAG,QAAQ,YAAY,CAAC;gCAiC1C,mBAAmB,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;kCAcjD,sBAAsB,KAAG,QAAQ,eAAe,CAAC;0BAczD,MAAM,WAAW,MAAM,KAAG,QAAQ,MAAM,CAAC;wCAc3B,MAAM,WAAW,MAAM,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;gCAc/D,MAAM,KAAG,QAAQ,SAAS,GAAG,IAAI,CAAC;8BAcpC,MAAM,WAAW,MAAM,QAAQ,SAAS,GAAG,IAAI,KAAG,QAAQ,MAAM,CAAC;6BAiCxE,QAAQ,KAAG,MAAM,EAAE,GAAG,SAAS;wDAuCzD,MAAM,SACf,QAAQ,cACJ,MAAM,KAChB,QAAQ,wBAAwB,CAAC;6CAqBlB,MAAM,SACf,QAAQ,cACJ,MAAM,KAChB,sBAAsB;;CAqB1B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}
+{"version":3,"file":"useWeb3.d.ts","sourceRoot":"","sources":["../../src/hooks/useWeb3.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,wBAAwB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAG1D,KAAK,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAGtE,YAAY,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,OAAO;+BAmCkC,mBAAmB,KAAG,QAAQ,YAAY,CAAC;gCAiC1C,mBAAmB,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;kCAcjD,sBAAsB,KAAG,QAAQ,eAAe,CAAC;0BAqBzD,MAAM,KAAG,QAAQ,MAAM,CAAC;wCAoBV,MAAM,KAAG,QAAQ,aAAa,GAAG,IAAI,CAAC;gCAc9C,MAAM,KAAG,QAAQ,SAAS,CAAC;8BAc7B,MAAM,WAAW,MAAM,QAAQ,SAAS,GAAG,IAAI,KAAG,QAAQ,MAAM,CAAC;6BAiCxE,QAAQ,KAAG,MAAM,EAAE,GAAG,SAAS;wDAuCzD,MAAM,SACf,QAAQ,cACJ,MAAM,KAChB,QAAQ,wBAAwB,CAAC;6CAqBlB,MAAM,SACf,QAAQ,cACJ,MAAM,KAChB,sBAAsB;;CAqB1B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}

package/dist/hooks/useWeb3.js

@@ -142,25 +142,38 @@ export const useWeb3 = () => {
             throw error;
         }
     }, [web3, isInitialized]);
-    const resolveIPFSUrl = useCallback(async (url, chainId) => {
-        if (!isInitialized || !web3) {
+    /**
+     * Resolve IPFS URL to HTTP gateway URL
+     *
+     * @deprecated Use `sdk.tenant.resolveIPFSUrl()` directly - IPFS is chain-agnostic
+     * @param url - IPFS URL to resolve (ipfs://...)
+     * @returns Promise resolving to HTTP gateway URL
+     */
+    const resolveIPFSUrl = useCallback(async (url) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await web3.resolveIPFSUrl(url, chainId);
+            const result = await sdk.tenants.resolveIPFSUrl(url);
             return result;
         }
         catch (error) {
             console.error('Failed to resolve IPFS URL:', error);
             throw error;
         }
-    }, [web3, isInitialized]);
-    const fetchAndProcessMetadata = useCallback(async (tokenUri, chainId) => {
+    }, [sdk, isInitialized]);
+    /**
+     * Fetch and process token metadata from a URI
+     *
+     * @param tokenUri - Token URI to fetch metadata from
+     * @returns Promise resolving to processed metadata or null
+     */
+    const fetchAndProcessMetadata = useCallback(async (tokenUri) => {
         if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await web3.fetchAndProcessMetadata(tokenUri, chainId);
+            const result = await web3.fetchAndProcessMetadata(tokenUri);
             return result;
         }
         catch (error) {
@@ -230,7 +243,7 @@ export const useWeb3 = () => {
      *
      * @param accountAddress - Any valid blockchain address (wallet, contract, etc.)
      * @param token - Token definition (from getRewardTokens, getStatusTokens, etc.)
-     * @param maxTokens - Maximum tokens to retrieve (default: 50)
+     * @param maxTokens - Maximum tokens to retrieve (default: 100, max: 100)
      * @returns Promise resolving to result with owned tokens
      * @throws Error if SDK is not initialized
      *
@@ -249,7 +262,7 @@ export const useWeb3 = () => {
      * @see {@link extractTokenIds} - Low-level helper used internally for ERC-1155
      * @see {@link buildCollectionRequest} - For manual request building
      */
-    const getAccountOwnedTokensFromContract = useCallback(async (accountAddress, token, maxTokens = 50) => {
+    const getAccountOwnedTokensFromContract = useCallback(async (accountAddress, token, maxTokens = 100) => {
         if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -264,10 +277,10 @@ export const useWeb3 = () => {
      *
      * @param accountAddress - Any valid blockchain address (wallet, contract, etc.)
      * @param token - Token definition
-     * @param maxTokens - Maximum tokens to retrieve (default: 50)
+     * @param maxTokens - Maximum tokens to retrieve (default: 100, max: 100)
      * @returns TokenCollectionRequest ready for getTokenCollection()
      */
-    const buildCollectionRequest = useCallback((accountAddress, token, maxTokens = 50) => {
+    const buildCollectionRequest = useCallback((accountAddress, token, maxTokens = 100) => {
         if (!web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }