@explorins/pers-sdk-react-native 2.1.21 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explorins/pers-sdk-react-native",
-  "version": "2.1.21",
+  "version": "2.1.22",
   "description": "React Native SDK for PERS Platform - Tourism Loyalty System with Blockchain Transaction Signing and WebAuthn Authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
   "author": "eXplorins",
   "license": "MIT",
   "dependencies": {
-    "@explorins/pers-sdk": "^2.1.31",
+    "@explorins/pers-sdk": "file:.yalc/@explorins/pers-sdk",
     "@explorins/pers-signer": "^1.0.33",
     "buffer": "^6.0.3",
     "ethers": "^6.15.0",

package/src/hooks/index.ts

@@ -8,7 +8,7 @@ export { useBusiness } from './useBusiness';
 export { useCampaigns } from './useCampaigns';
 export { useRedemptions } from './useRedemptions';
 export { useWeb3 } from './useWeb3';
-export { useResolvedUrl, useMetadata, useIPFSUrl } from './useIPFSUrl';
+export { useResolvedUrl, useMetadata, useIPFSUrl, useTransactionMetadata } from './useIPFSUrl';
 export { usePurchases } from './usePurchases';
 export { useTenants } from './useTenants';
 export { useUsers } from './useUsers';

package/src/hooks/useIPFSUrl.ts

@@ -1,6 +1,6 @@
-import { useState, useEffect } from 'react';
-import { useWeb3 } from './useWeb3';
-import type { TokenMetadata } from '@explorins/pers-sdk/web3';
+import { useState, useEffect, useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { TokenMetadata } from '@explorins/pers-sdk';
 
 /**
  * React hook for resolving media URLs (IPFS or HTTPS).
@@ -8,6 +8,8 @@ import type { TokenMetadata } from '@explorins/pers-sdk/web3';
  * Automatically handles IPFS URLs by resolving them to HTTPS via tenant's gateway.
  * Non-IPFS URLs are returned as-is. Handles loading and error states.
  * 
+ * Uses sdk.tenants for IPFS resolution (lightweight, no Web3 deps).
+ * 
  * @param url - The URL to resolve (can be ipfs://, https://, or undefined)
  * @returns Object with resolved URL, loading state, and error
  * 
@@ -22,13 +24,13 @@ import type { TokenMetadata } from '@explorins/pers-sdk/web3';
  * ```
  */
 export function useResolvedUrl(url: string | undefined | null) {
-  const { resolveIPFSUrl, isAvailable } = useWeb3();
+  const { sdk, isInitialized } = usePersSDK();
   const [resolvedUrl, setResolvedUrl] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
-    if (!url || !isAvailable) {
+    if (!url || !isInitialized || !sdk) {
       setResolvedUrl(null);
       return;
     }
@@ -42,7 +44,7 @@ export function useResolvedUrl(url: string | undefined | null) {
     setIsLoading(true);
     setError(null);
 
-    resolveIPFSUrl(url)
+    sdk.tenants.resolveIpfsUrl(url)
       .then((resolved) => {
         setResolvedUrl(resolved);
       })
@@ -53,7 +55,7 @@ export function useResolvedUrl(url: string | undefined | null) {
       .finally(() => {
         setIsLoading(false);
       });
-  }, [url, isAvailable, resolveIPFSUrl]);
+  }, [url, isInitialized, sdk]);
 
   return {
     /** Resolved HTTPS URL (or original if not IPFS) */
@@ -71,6 +73,8 @@ export function useResolvedUrl(url: string | undefined | null) {
  * Handles IPFS resolution automatically and returns parsed metadata
  * with all nested IPFS URLs already resolved to HTTPS.
  * 
+ * Uses sdk.tenants for metadata fetching (lightweight, no Web3 deps).
+ * 
  * @param metadataUri - The metadata URI to fetch (can be ipfs:// or https://)
  * @returns Object with metadata, loading state, error, and refresh function
  * 
@@ -94,13 +98,13 @@ export function useResolvedUrl(url: string | undefined | null) {
  * ```
  */
 export function useMetadata(metadataUri: string | undefined | null) {
-  const { fetchAndProcessMetadata, isAvailable } = useWeb3();
+  const { sdk, isInitialized } = usePersSDK();
   const [metadata, setMetadata] = useState<TokenMetadata | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
-  const fetchMetadata = async () => {
-    if (!metadataUri || !isAvailable) {
+  const fetchMetadata = useCallback(async () => {
+    if (!metadataUri || !isInitialized || !sdk) {
       setMetadata(null);
       return;
     }
@@ -109,7 +113,7 @@ export function useMetadata(metadataUri: string | undefined | null) {
     setError(null);
 
     try {
-      const result = await fetchAndProcessMetadata(metadataUri);
+      const result = await sdk.tenants.fetchAndProcessMetadata(metadataUri);
       setMetadata(result);
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Failed to fetch metadata');
@@ -117,11 +121,11 @@ export function useMetadata(metadataUri: string | undefined | null) {
     } finally {
       setIsLoading(false);
     }
-  };
+  }, [metadataUri, isInitialized, sdk]);
 
   useEffect(() => {
     fetchMetadata();
-  }, [metadataUri, isAvailable]);
+  }, [fetchMetadata]);
 
   return {
     /** Parsed metadata with resolved IPFS URLs (imageUrl, animationUrl, etc.) */
@@ -137,3 +141,52 @@ export function useMetadata(metadataUri: string | undefined | null) {
 
 // Re-export with descriptive aliases
 export { useResolvedUrl as useIPFSUrl };
+
+/**
+ * React hook for loading transaction/token metadata.
+ * 
+ * Convenience wrapper around useMetadata specifically for transaction items.
+ * Pass a transaction's metadataUri to get the NFT image, name, description, etc.
+ * 
+ * @param transaction - Transaction object with optional metadataUri field
+ * @returns Object with metadata, loading state, and image URL
+ * 
+ * @example
+ * ```tsx
+ * import { useTransactionMetadata } from '@explorins/pers-sdk-react-native';
+ * 
+ * function TransactionItem({ tx }: { tx: TransactionDTO }) {
+ *   const { metadata, isLoading, imageUrl } = useTransactionMetadata(tx);
+ *   
+ *   if (isLoading) return <ActivityIndicator />;
+ *   
+ *   return (
+ *     <View>
+ *       {imageUrl && <Image source={{ uri: imageUrl }} style={{ width: 60, height: 60 }} />}
+ *       <Text>{metadata?.name || tx.type}</Text>
+ *       <Text>{tx.amount} tokens</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export function useTransactionMetadata(transaction: { metadataUri?: string | null } | null | undefined) {
+  const { metadata, isLoading, error, refresh } = useMetadata(transaction?.metadataUri);
+  
+  return {
+    /** Parsed metadata with resolved URLs */
+    metadata,
+    /** Whether metadata is loading */
+    isLoading,
+    /** Error message if fetch failed */
+    error,
+    /** Convenience: resolved image URL (or undefined) */
+    imageUrl: metadata?.imageUrl,
+    /** Convenience: token/NFT name (or undefined) */
+    name: metadata?.name,
+    /** Convenience: token/NFT description (or undefined) */
+    description: metadata?.description,
+    /** Manually refresh metadata */
+    refresh,
+  };
+}

package/src/hooks/useWeb3.ts

@@ -169,6 +169,8 @@ export const useWeb3 = () => {
    * Converts an ipfs:// URL to an HTTPS URL using the tenant's configured IPFS gateway.
    * Non-IPFS URLs are returned unchanged.
    * 
+   * Note: Uses sdk.tenants for IPFS resolution (chain-agnostic).
+   * 
    * @param url - IPFS URL to resolve (ipfs://...)
    * @returns Promise resolving to HTTP gateway URL
    * 
@@ -180,38 +182,40 @@ export const useWeb3 = () => {
    * ```
    */
   const resolveIPFSUrl = useCallback(async (url: string): Promise<string> => {
-    if (!isInitialized || !web3) {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await web3.resolveIPFSUrl(url);
+      const result = await sdk.tenants.resolveIpfsUrl(url);
       return result;
     } catch (error) {
       console.error('Failed to resolve IPFS URL:', error);
       throw error;
     }
-  }, [web3, isInitialized]);
+  }, [sdk, isInitialized]);
 
   /**
    * Fetch and process token metadata from a URI
    * 
+   * Note: Uses sdk.tenants for metadata fetching (chain-agnostic IPFS).
+   * 
    * @param tokenUri - Token URI to fetch metadata from
    * @returns Promise resolving to processed metadata or null
    */
   const fetchAndProcessMetadata = useCallback(async (tokenUri: string): Promise<TokenMetadata | null> => {
-    if (!isInitialized || !web3) {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await web3.fetchAndProcessMetadata(tokenUri);
+      const result = await sdk.tenants.fetchAndProcessMetadata(tokenUri);
       return result;
     } catch (error) {
       console.error('Failed to fetch and process metadata:', error);
       throw error;
     }
-  }, [web3, isInitialized]);
+  }, [sdk, isInitialized]);
 
   const getChainDataById = useCallback(async (chainId: number): Promise<ChainData> => {
     if (!isInitialized || !web3) {

package/src/index.ts

@@ -263,7 +263,12 @@ export {
   useAnalytics,
   useDonations,
   useEvents,
-  useTriggerSources
+  useTriggerSources,
+  // IPFS hooks - for resolving ipfs:// URLs and loading metadata
+  useResolvedUrl,
+  useMetadata,
+  useIPFSUrl, // alias for useResolvedUrl
+  useTransactionMetadata // convenience for transaction items
 } from './hooks';
 
 // Re-export signing status types for convenience