@explorins/pers-sdk-react-native 1.3.2

package/README.md

@@ -0,0 +1,200 @@
+# PERS SDK - React Native
+
+React Native SDK for PERS Platform - Tourism Loyalty System. This package provides React Native-specific implementations of authentication providers and HTTP clients that integrate seamlessly with the PERS SDK.
+
+## Features
+
+- 🔐 **Multiple Storage Strategies**: AsyncStorage, Keychain, or Memory
+- 🛡️ **Security-First**: Configurable security levels per token type  
+- 📱 **Cross-Platform**: iOS, Android, and Web support
+- 🎯 **Blueprint Ready**: Serves as blueprint for native iOS/Android implementations
+- 🔧 **Flexible Configuration**: Customizable storage and security options
+- 📦 **TypeScript**: Full type safety and IntelliSense support
+
+## Installation
+
+```bash
+npm install @explorins/pers-sdk-react-native @explorins/pers-sdk @react-native-async-storage/async-storage
+```
+
+### Optional Dependencies
+
+For enhanced security (Keychain storage):
+```bash
+npm install react-native-keychain
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { 
+  PersApiClient,
+  SimpleReactNativeAuthProvider,
+  ReactNativeHttpClient 
+} from '@explorins/pers-sdk-react-native';
+
+// Create HTTP client
+const httpClient = new ReactNativeHttpClient();
+
+// Create auth provider
+const authProvider = new SimpleReactNativeAuthProvider('your-project-key');
+
+// Create API client
+const apiClient = new PersApiClient(httpClient, {
+  environment: 'staging',
+  apiVersion: 'v2',
+  apiProjectKey: 'your-project-key',
+  authProvider: authProvider,
+});
+
+// Login and store tokens automatically
+const result = await apiClient.loginUser('your-jwt-token');
+console.log('Logged in:', result.user);
+```
+
+### Secure Usage (with Keychain)
+
+```typescript
+import { 
+  SecureReactNativeAuthProvider,
+  StorageStrategy 
+} from '@explorins/pers-sdk-react-native';
+
+// Maximum security - all tokens in Keychain
+const authProvider = new SecureReactNativeAuthProvider('your-project-key', {
+  debug: true // Enable debug logging
+});
+```
+
+### Custom Configuration
+
+```typescript
+import { 
+  BaseReactNativeAuthProvider,
+  StorageStrategy 
+} from '@explorins/pers-sdk-react-native';
+
+class CustomAuthProvider extends BaseReactNativeAuthProvider {
+  readonly authType = 'user' as const;
+
+  constructor(projectKey: string) {
+    super(projectKey, {
+      accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
+      refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+      keyPrefix: 'myapp',
+      debug: __DEV__
+    });
+  }
+
+  async getProjectKey(): Promise<string | null> {
+    return 'your-project-key';
+  }
+
+  async onTokenExpired(): Promise<void> {
+    // Implement token refresh logic
+    console.log('Token expired - implement refresh');
+  }
+}
+```
+
+## Storage Strategies
+
+### AsyncStorage (Default)
+- **Use Case**: General app data, user preferences
+- **Security**: Basic - data is stored unencrypted locally
+- **Availability**: Always available on React Native
+
+### Keychain (Recommended for Tokens)
+- **Use Case**: Sensitive data like JWT tokens
+- **Security**: High - uses iOS Keychain / Android Keystore
+- **Availability**: Requires `react-native-keychain` package
+
+### Memory
+- **Use Case**: Temporary data, development, fallback
+- **Security**: High - data cleared on app termination
+- **Availability**: Always available
+
+## API Reference
+
+### SimpleReactNativeAuthProvider
+
+Ready-to-use provider with sensible defaults:
+- Access tokens: AsyncStorage
+- Refresh tokens: Keychain (fallback to AsyncStorage)
+
+```typescript
+const authProvider = new SimpleReactNativeAuthProvider(projectKey, {
+  debug: true,
+  keyPrefix: 'custom_prefix'
+});
+```
+
+### SecureReactNativeAuthProvider
+
+Maximum security provider:
+- All tokens: Keychain storage
+- Automatic fallback to AsyncStorage if Keychain unavailable
+
+```typescript
+const authProvider = new SecureReactNativeAuthProvider(projectKey);
+```
+
+### BaseReactNativeAuthProvider
+
+Extendable base class for custom implementations:
+
+```typescript
+class MyAuthProvider extends BaseReactNativeAuthProvider {
+  // Implement required methods
+}
+```
+
+## Integration with PERS SDK
+
+This package works seamlessly with all PERS SDK features:
+
+```typescript
+import { 
+  createWeb3SDK,
+  createBusinessSDK,
+  TokenSDK 
+} from '@explorins/pers-sdk-react-native';
+
+// All SDK features are available
+const web3SDK = createWeb3SDK(apiClient);
+const tokenSDK = new TokenSDK(apiClient);
+const businessSDK = createBusinessSDK(apiClient);
+```
+
+## Native Implementation Blueprint
+
+This React Native SDK serves as a blueprint for native iOS and Android implementations:
+
+### iOS Blueprint
+- AsyncStorage → NSUserDefaults
+- Keychain → iOS Keychain Services  
+- HTTP Client → NSURLSession
+
+### Android Blueprint  
+- AsyncStorage → SharedPreferences
+- Keychain → Android Keystore
+- HTTP Client → OkHttp/Retrofit
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the package
+npm run build
+
+# Watch mode for development
+npm run dev
+```
+
+## License
+
+MIT License - see LICENSE file for details.

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export { useAuth } from './useAuth';
+export { useTokens } from './useTokens';
+export { useTransactions } from './useTransactions';
+export { useBusiness } from './useBusiness';
+export { useCampaigns } from './useCampaigns';
+export { useRedemptions } from './useRedemptions';
+export { useWeb3 } from './useWeb3';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,8 @@
+// Export all hooks (only hooks, no providers to avoid circular dependency)
+export { useAuth } from './useAuth';
+export { useTokens } from './useTokens';
+export { useTransactions } from './useTransactions';
+export { useBusiness } from './useBusiness';
+export { useCampaigns } from './useCampaigns';
+export { useRedemptions } from './useRedemptions';
+export { useWeb3 } from './useWeb3';

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,12 @@
+export interface AuthHook {
+    isInitialized: boolean;
+    isAuthenticated: boolean;
+    user: any | null;
+    accountAddress: string | null;
+    initialize: (config: any) => Promise<void>;
+    login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
+    loginWithRawData: (rawUserData: any) => Promise<any>;
+    logout: () => Promise<void>;
+}
+export declare const useAuth: () => AuthHook;
+//# sourceMappingURL=useAuth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IAEvB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACvE,gBAAgB,EAAE,CAAC,WAAW,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED,eAAO,MAAM,OAAO,QAAO,QAyB1B,CAAC"}

package/dist/hooks/useAuth.js

@@ -0,0 +1,16 @@
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useAuth = () => {
+    const { isInitialized, isAuthenticated, user, accountAddress, initialize, login, loginWithRawData, logout, } = usePersSDK();
+    return {
+        // State
+        isInitialized,
+        isAuthenticated,
+        user,
+        accountAddress,
+        // Actions
+        initialize,
+        login,
+        loginWithRawData,
+        logout,
+    };
+};

package/dist/hooks/useBusiness.d.ts

@@ -0,0 +1,7 @@
+export declare const useBusiness: () => {
+    getActiveBusinesses: () => Promise<any>;
+    getAllBusinessTypes: () => Promise<any>;
+    getBusinessById: (businessId: string) => Promise<any>;
+    isAvailable: boolean;
+};
+//# sourceMappingURL=useBusiness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBusiness.d.ts","sourceRoot":"","sources":["../../src/hooks/useBusiness.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;;kCAyCiC,MAAM;;CAwB9D,CAAC"}

package/dist/hooks/useBusiness.js

@@ -0,0 +1,64 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useBusiness = () => {
+    const { business, isInitialized } = usePersSDK();
+    const getActiveBusinesses = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!business?.getActiveBusinesses) {
+            console.warn('getActiveBusinesses method not available');
+            return [];
+        }
+        try {
+            const result = await business.getActiveBusinesses();
+            console.log('✅ Active businesses fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch active businesses:', error);
+            throw error;
+        }
+    }, [business]);
+    const getAllBusinessTypes = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!business?.getAllBusinessTypes) {
+            console.warn('getAllBusinessTypes method not available');
+            return [];
+        }
+        try {
+            const result = await business.getAllBusinessTypes();
+            console.log('✅ Business types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch business types:', error);
+            throw error;
+        }
+    }, [business]);
+    const getBusinessById = useCallback(async (businessId) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!business?.getBusinessById) {
+            throw new Error('getBusinessById method not available');
+        }
+        try {
+            const result = await business.getBusinessById(businessId);
+            console.log('✅ Business fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch business:', error);
+            throw error;
+        }
+    }, [business]);
+    return {
+        getActiveBusinesses,
+        getAllBusinessTypes,
+        getBusinessById,
+        isAvailable: isInitialized && !!business,
+    };
+};

package/dist/hooks/useCampaigns.d.ts

@@ -0,0 +1,8 @@
+export declare const useCampaigns: () => {
+    getActiveCampaigns: () => Promise<any>;
+    getCampaignById: (campaignId: string) => Promise<any>;
+    claimCampaign: (request: any) => Promise<any>;
+    getClaimsForLoggedUser: () => Promise<any>;
+    isAvailable: boolean;
+};
+//# sourceMappingURL=useCampaigns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCampaigns.d.ts","sourceRoot":"","sources":["../../src/hooks/useCampaigns.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;kCAsBgC,MAAM;6BAkBX,GAAG;;;CAoDtD,CAAC"}

package/dist/hooks/useCampaigns.js

@@ -0,0 +1,90 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useCampaigns = () => {
+    const { campaigns, isInitialized, isAuthenticated } = usePersSDK();
+    const getActiveCampaigns = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!campaigns?.getActiveCampaigns) {
+            console.warn('getActiveCampaigns method not available');
+            return [];
+        }
+        try {
+            const result = await campaigns.getActiveCampaigns();
+            console.log('✅ Active campaigns fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch active campaigns:', error);
+            throw error;
+        }
+    }, [campaigns]);
+    const getCampaignById = useCallback(async (campaignId) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!campaigns?.getCampaignById) {
+            throw new Error('getCampaignById method not available');
+        }
+        try {
+            const result = await campaigns.getCampaignById(campaignId);
+            console.log('✅ Campaign fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch campaign:', error);
+            throw error;
+        }
+    }, [campaigns]);
+    const claimCampaign = useCallback(async (request) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. claimCampaign requires authentication.');
+        }
+        if (!campaigns?.claimCampaign) {
+            throw new Error('claimCampaign method not available');
+        }
+        try {
+            console.log('🔄 Claiming campaign with request:', request);
+            const result = await campaigns.claimCampaign(request);
+            console.log('✅ Campaign claimed successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to claim campaign:', error);
+            throw error;
+        }
+    }, [isInitialized, isAuthenticated, campaigns]);
+    const getClaimsForLoggedUser = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            console.warn('SDK not authenticated. getClaimsForLoggedUser requires authentication.');
+            return [];
+        }
+        if (!campaigns?.getClaimsForLoggedUser) {
+            console.warn('getClaimsForLoggedUser method not available');
+            return [];
+        }
+        try {
+            const result = await campaigns.getClaimsForLoggedUser();
+            console.log('✅ User claims fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch user claims:', error);
+            throw error;
+        }
+    }, [isInitialized, isAuthenticated, campaigns]);
+    return {
+        getActiveCampaigns,
+        getCampaignById,
+        claimCampaign,
+        getClaimsForLoggedUser,
+        isAvailable: isInitialized && !!campaigns,
+    };
+};

package/dist/hooks/useRedemptions.d.ts

@@ -0,0 +1,9 @@
+export declare const useRedemptions: () => {
+    createRedemption: (redemptionData: any) => Promise<any>;
+    getActiveRedemptions: () => Promise<any>;
+    getUserRedeems: () => Promise<any>;
+    redeemRedemption: (redemptionId: string) => Promise<any>;
+    getRedemptionById: (redemptionId: string) => Promise<any>;
+    isAvailable: boolean;
+};
+//# sourceMappingURL=useRedemptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;uCAImC,GAAG;;;qCA6DL,MAAM;sCAkCL,MAAM;;CA0BlE,CAAC"}

package/dist/hooks/useRedemptions.js

@@ -0,0 +1,121 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useRedemptions = () => {
+    const { redemptions, isInitialized, isAuthenticated } = usePersSDK();
+    // Admin method: Create new redemption offers
+    const createRedemption = useCallback(async (redemptionData) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!redemptions?.createRedemption) {
+            throw new Error('createRedemption method not available - admin access required');
+        }
+        try {
+            console.log('🔄 Creating redemption offer with data:', redemptionData);
+            const result = await redemptions.createRedemption(redemptionData);
+            console.log('✅ Redemption offer created successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to create redemption offer:', error);
+            throw error;
+        }
+    }, [redemptions]);
+    const getActiveRedemptions = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!redemptions?.getActiveRedemptions) {
+            console.warn('getActiveRedemptions method not available');
+            return [];
+        }
+        try {
+            const result = await redemptions.getActiveRedemptions();
+            console.log('✅ Active redemptions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch active redemptions:', error);
+            throw error;
+        }
+    }, [redemptions]);
+    const getUserRedeems = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            console.warn('SDK not authenticated. getUserRedeems requires authentication.');
+            return [];
+        }
+        if (!redemptions?.getUserRedeems) {
+            console.warn('getUserRedeems method not available');
+            return [];
+        }
+        try {
+            const result = await redemptions.getUserRedeems();
+            console.log('✅ User redemptions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch user redemptions:', error);
+            throw error;
+        }
+    }, [isInitialized, isAuthenticated, redemptions]);
+    const redeemRedemption = useCallback(async (redemptionId) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. redeemRedemption requires authentication.');
+        }
+        if (!redemptions?.redeemRedemption) {
+            throw new Error('redeemRedemption method not available');
+        }
+        try {
+            console.log('🔄 Redeeming redemption:', redemptionId);
+            const result = await redemptions.redeemRedemption(redemptionId);
+            // React Native specific: Handle signature URLs for redemptions
+            if (result?.actionable?.actionUrl) {
+                try {
+                    const { Linking } = require('react-native');
+                    console.log('🔗 Opening redemption signature URL:', result.actionable.actionUrl);
+                    await Linking.openURL(result.actionable.actionUrl);
+                }
+                catch (linkingError) {
+                    console.error('❌ Failed to open redemption signature URL:', linkingError);
+                }
+            }
+            console.log('✅ Redemption processed successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to redeem redemption:', error);
+            throw error;
+        }
+    }, [isInitialized, isAuthenticated, redemptions]);
+    const getRedemptionById = useCallback(async (redemptionId) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!redemptions?.getRedemptionById) {
+            throw new Error('getRedemptionById method not available');
+        }
+        try {
+            const result = await redemptions.getRedemptionById(redemptionId);
+            console.log('✅ Redemption fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch redemption:', error);
+            throw error;
+        }
+    }, [redemptions]);
+    return {
+        createRedemption,
+        getActiveRedemptions,
+        getUserRedeems,
+        redeemRedemption,
+        getRedemptionById,
+        isAvailable: isInitialized && !!redemptions,
+    };
+};

package/dist/hooks/useTokens.d.ts

@@ -0,0 +1,6 @@
+export declare const useTokens: () => {
+    getTokens: () => Promise<any>;
+    getTokenById: (tokenId: string) => Promise<any>;
+    isAvailable: boolean;
+};
+//# sourceMappingURL=useTokens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokens.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS;;4BA0B6B,MAAM;;CAuBxD,CAAC"}

package/dist/hooks/useTokens.js

@@ -0,0 +1,48 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useTokens = () => {
+    const { tokens, isInitialized, isAuthenticated } = usePersSDK();
+    if (!isAuthenticated && isInitialized) {
+        console.warn('SDK not authenticated. Some token operations may fail.');
+    }
+    const getTokens = useCallback(async () => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!tokens?.getTokens) {
+            console.warn('getTokens method not available');
+            return [];
+        }
+        try {
+            const result = await tokens.getTokens();
+            console.log('✅ Tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch tokens:', error);
+            throw error;
+        }
+    }, [tokens]);
+    const getTokenById = useCallback(async (tokenId) => {
+        if (!isInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!tokens?.getTokenById) {
+            throw new Error('getTokenById method not available');
+        }
+        try {
+            const result = await tokens.getTokenById(tokenId);
+            console.log('✅ Token fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to fetch token:', error);
+            throw error;
+        }
+    }, [tokens]);
+    return {
+        getTokens,
+        getTokenById,
+        isAvailable: isInitialized && !!tokens,
+    };
+};

package/dist/hooks/useTransactions.d.ts

@@ -0,0 +1,7 @@
+export declare const useTransactions: () => {
+    createTransaction: (request: any) => Promise<any>;
+    getTransactionById: (transactionId: string) => Promise<any>;
+    getTransactionHistory: (filters?: any) => Promise<any>;
+    isAvailable: boolean;
+};
+//# sourceMappingURL=useTransactions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;iCAO4B,GAAG;wCA+BI,MAAM;sCAkBR,GAAG;;CAyB/D,CAAC"}