@explorins/pers-sdk-react-native 1.5.32 → 1.5.33

package/dist/hooks/useWeb3.js

@@ -103,7 +103,7 @@ export const useWeb3 = () => {
      *   chainId: 1
      * });
      * console.log('NFT name:', metadata?.name);
-     * console.log('NFT image:', metadata?.image);
+     * console.log('NFT image:', metadata?.imageUrl); // IPFS URLs auto-resolved to HTTPS
      * ```
      */
     const getTokenMetadata = useCallback(async (request) => {

package/dist/index.js

@@ -22507,21 +22507,115 @@ const getTokenOfOwnerByIndex = async (tokenContract, ownerAddress, index) => {
 };
 
 /**
- * Clean an ABI to be compatible with Ethers.js
- * Removes 'indexed' property from function inputs (only valid for events)
+ * Clean input/output parameters for functions, constructors, errors
+ * Removes properties that are invalid for non-event parameters
+ */
+function cleanInputsOrOutputs(params) {
+    if (!Array.isArray(params)) {
+        return [];
+    }
+    return params.map((param) => {
+        if (!param || typeof param !== 'object') {
+            return param;
+        }
+        const cleanParam = {
+            name: param.name ?? '',
+            type: param.type ?? 'uint256', // Default to uint256 if type is missing (shouldn't happen)
+        };
+        // Handle tuple types with components
+        if (param.components && Array.isArray(param.components)) {
+            cleanParam.components = cleanInputsOrOutputs(param.components);
+        }
+        // Preserve internalType only if it doesn't cause issues
+        // (some malformed internalTypes can break ethers)
+        if (param.internalType && typeof param.internalType === 'string') {
+            cleanParam.internalType = param.internalType;
+        }
+        // NOTE: 'indexed' is intentionally NOT included here
+        // It's only valid for event parameters
+        return cleanParam;
+    });
+}
+/**
+ * Clean an ABI to be compatible with Ethers.js v6
+ * Handles common Web3.js ABI format incompatibilities:
+ * - Removes 'indexed' from function inputs (only valid for event parameters)
+ * - Removes 'indexed' from function outputs
+ * - Removes 'internalType' if it causes parsing issues
+ * - Ensures 'stateMutability' is valid
+ * - Removes unknown/invalid properties that cause ethers to drop fragments
  */
 function cleanABI(abi) {
     return abi.map(fragment => {
-        if (fragment.type === 'function' && fragment.inputs) {
-            return {
-                ...fragment,
-                inputs: fragment.inputs.map((input) => {
-                    const { indexed, ...cleanInput } = input;
-                    return cleanInput;
-                })
-            };
+        // Skip non-object fragments
+        if (!fragment || typeof fragment !== 'object') {
+            return fragment;
         }
-        return fragment;
+        const cleanFragment = {
+            type: fragment.type,
+            name: fragment.name,
+        };
+        // Handle functions
+        if (fragment.type === 'function') {
+            // Clean inputs - remove 'indexed' (only valid for events)
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+            // Clean outputs - remove 'indexed'
+            if (fragment.outputs) {
+                cleanFragment.outputs = cleanInputsOrOutputs(fragment.outputs);
+            }
+            // Preserve valid function properties
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+            // Handle legacy 'constant' and 'payable' for older ABIs
+            if (fragment.constant !== undefined && !fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.constant ? 'view' : 'nonpayable';
+            }
+            if (fragment.payable && !fragment.stateMutability) {
+                cleanFragment.stateMutability = 'payable';
+            }
+        }
+        // Handle events - 'indexed' IS valid here
+        else if (fragment.type === 'event') {
+            cleanFragment.anonymous = fragment.anonymous ?? false;
+            if (fragment.inputs) {
+                cleanFragment.inputs = fragment.inputs.map((input) => ({
+                    name: input.name ?? '',
+                    type: input.type,
+                    indexed: input.indexed ?? false,
+                    // Keep internalType for events if present
+                    ...(input.internalType && { internalType: input.internalType })
+                }));
+            }
+        }
+        // Handle constructor
+        else if (fragment.type === 'constructor') {
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+        }
+        // Handle fallback/receive
+        else if (fragment.type === 'fallback' || fragment.type === 'receive') {
+            if (fragment.stateMutability) {
+                cleanFragment.stateMutability = fragment.stateMutability;
+            }
+        }
+        // Handle errors
+        else if (fragment.type === 'error') {
+            if (fragment.inputs) {
+                cleanFragment.inputs = cleanInputsOrOutputs(fragment.inputs);
+            }
+        }
+        // Pass through unknown types unchanged
+        else {
+            return fragment;
+        }
+        return cleanFragment;
     });
 }
 /**
@@ -22553,24 +22647,45 @@ function convertAbiToInterface(abi) {
             return abi;
         }
         // String format (JSON)
+        let abiArray;
         if (typeof abi === 'string') {
-            const parsedAbi = JSON.parse(abi);
-            const cleanedAbi = Array.isArray(parsedAbi) ? cleanABI(parsedAbi) : parsedAbi;
-            return new Interface(cleanedAbi);
+            abiArray = JSON.parse(abi);
+        }
+        else if (Array.isArray(abi)) {
+            abiArray = abi;
         }
-        // Array or object format
-        if (Array.isArray(abi) || typeof abi === 'object') {
-            const cleanedAbi = Array.isArray(abi) ? cleanABI(abi) : abi;
-            return new Interface(cleanedAbi);
+        else if (typeof abi === 'object') {
+            // Single fragment object
+            abiArray = [abi];
         }
-        throw new Error(`Unsupported ABI type: ${typeof abi}`);
+        else {
+            throw new Error(`Unsupported ABI type: ${typeof abi}`);
+        }
+        // Clean the ABI
+        const cleanedAbi = cleanABI(abiArray);
+        // Try to create Interface and validate all fragments were parsed
+        const iface = new Interface(cleanedAbi);
+        // Validation: Check if expected functions are present
+        const expectedFunctions = cleanedAbi
+            .filter((f) => f.type === 'function')
+            .map((f) => f.name);
+        const actualFunctions = iface.fragments
+            .filter(f => f.type === 'function')
+            .map(f => f.name);
+        const droppedFunctions = expectedFunctions.filter((name) => !actualFunctions.includes(name));
+        if (droppedFunctions.length > 0) {
+            console.warn(`[web3-ts] Warning: ${droppedFunctions.length} function(s) were dropped during ABI conversion:`, droppedFunctions.join(', '));
+        }
+        return iface;
     }
     catch (error) {
         if (error.message.includes('JSON')) {
             throw new Error('Invalid JSON format in ABI string');
         }
-        if (error.message.includes('invalid fragment') || error.message.includes('parameter cannot be indexed')) {
-            throw new Error('Invalid ABI fragment structure - function inputs cannot be indexed');
+        if (error.message.includes('invalid fragment') ||
+            error.message.includes('parameter cannot be indexed')) {
+            console.error('[web3-ts] ABI fragment error:', error.message);
+            throw new Error(`Invalid ABI fragment structure: ${error.message}`);
         }
         throw error;
     }
@@ -23974,7 +24089,7 @@ class CampaignApi {
      * NEW: GET /trigger-sources
      */
     async getCampaignTriggers(options) {
-        let url = '/trigger-sources';
+        let url = '/campaign-triggers';
         const params = [];
         if (options) {
             if (options.limit)
@@ -25402,6 +25517,17 @@ class IPFSInfrastructureApi {
         }
         return url;
     }
+    /**
+     * Fetch metadata from tokenURI, resolve all IPFS URLs, and normalize to SDK format.
+     *
+     * NORMALIZATION BOUNDARY: This is the single place where ERC metadata standard
+     * (snake_case: image, animation_url) is converted to SDK format (camelCase: imageUrl, animationUrl).
+     * All downstream consumers receive normalized SDK format with resolved HTTPS URLs.
+     *
+     * @param tokenUri - Token URI (can be ipfs:// or https://)
+     * @param chainId - Chain ID for IPFS gateway selection
+     * @returns Normalized TokenMetadata with resolved HTTPS URLs, or null on error
+     */
     async fetchAndProcessMetadata(tokenUri, chainId) {
         try {
             const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
@@ -25409,15 +25535,25 @@ class IPFSInfrastructureApi {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
-            const metadata = await response.json();
-            // Process and return clean metadata
+            const rawMetadata = await response.json();
+            // Resolve IPFS URLs for media fields
+            const resolvedImageUrl = rawMetadata.image
+                ? await this.resolveIPFSUrl(rawMetadata.image, chainId)
+                : '';
+            const resolvedAnimationUrl = rawMetadata.animation_url
+                ? await this.resolveIPFSUrl(rawMetadata.animation_url, chainId)
+                : undefined;
+            // Extract custom properties (anything not in ERC standard)
+            const customProperties = Object.fromEntries(Object.entries(rawMetadata).filter(([key]) => !['name', 'description', 'image', 'animation_url', 'external_url', 'attributes'].includes(key)));
+            // Return normalized SDK format (typed as TokenMetadata)
             return {
-                name: metadata.name || '',
-                description: metadata.description || '',
-                image: metadata.image ? await this.resolveIPFSUrl(metadata.image, chainId) : '',
-                attributes: metadata.attributes || [],
-                animation_url: metadata.animation_url ? await this.resolveIPFSUrl(metadata.animation_url, chainId) : undefined,
-                external_url: metadata.external_url || undefined
+                name: rawMetadata.name || '',
+                description: rawMetadata.description || '',
+                imageUrl: resolvedImageUrl,
+                animationUrl: resolvedAnimationUrl,
+                externalUrl: rawMetadata.external_url || undefined,
+                attributes: rawMetadata.attributes || [],
+                ...customProperties
             };
         }
         catch (error) {
@@ -25701,8 +25837,8 @@ class MetadataDomainService {
 class ContractDomainService {
     constructor() { }
     analyzeContract(abi) {
-        abi = convertAbiToInterface(abi);
-        const methods = abi.fragments.filter(item => item.type === 'function').map(item => item.name);
+        const cleanAbi = convertAbiToInterface(abi);
+        const methods = cleanAbi.fragments.filter(item => item.type === 'function').map(item => item.name);
         // ERC-721 detection
         const hasOwnerOf = methods.includes('ownerOf');
         const hasTokenURI = methods.includes('tokenURI');
@@ -25733,28 +25869,6 @@ class ContractDomainService {
  */
 class Web3ApplicationService {
     constructor(web3Api, ipfsApi) {
-        // Type-safe metadata conversion methods for ERC-721/ERC-1155 standards
-        this.metadataMapper = {
-            fromERCStandard: (ercMetadata) => ({
-                name: ercMetadata.name || '',
-                description: ercMetadata.description || '',
-                imageUrl: ercMetadata.image || '',
-                externalUrl: ercMetadata.external_url,
-                animationUrl: ercMetadata.animation_url,
-                animationUrlConverted: undefined, // Will be set by IPFS conversion
-                attributes: ercMetadata.attributes || [],
-                ...ercMetadata
-            }),
-            toERCStandard: (metadata) => ({
-                name: metadata.name,
-                description: metadata.description,
-                image: metadata.imageUrl,
-                animation_url: metadata.animationUrl,
-                external_url: metadata.externalUrl,
-                attributes: metadata.attributes,
-                ...Object.fromEntries(Object.entries(metadata).filter(([key]) => !['name', 'description', 'imageUrl', 'animationUrl', 'externalUrl', 'attributes', 'animationUrlConverted'].includes(key)))
-            })
-        };
         // Create domain services with injected infrastructure dependencies
         this.contractDomainService = new ContractDomainService();
         this.metadataDomainService = new MetadataDomainService(ipfsApi);
@@ -25773,7 +25887,15 @@ class Web3ApplicationService {
         });
     }
     /**
-     * Get metadata for a specific token from on-chain
+     * Get metadata for a specific token from on-chain.
+     *
+     * Returns metadata with:
+     * - Normalized property names (imageUrl, animationUrl - SDK standard)
+     * - All IPFS URLs already resolved to HTTPS
+     * - Custom properties preserved from original metadata
+     *
+     * Note: Normalization happens at infrastructure layer (IPFS API),
+     * so no additional transformation needed here.
      */
     async getTokenMetadata(request) {
         const domainResult = await this.tokenDomainService.getTokenMetadata({
@@ -25782,6 +25904,7 @@ class Web3ApplicationService {
             tokenId: request.tokenId || '',
             chainId: request.chainId
         });
+        // Metadata is already normalized at infrastructure layer
         return domainResult.metadata;
     }
     /**
@@ -25804,22 +25927,13 @@ class Web3ApplicationService {
         return this.metadataDomainService.resolveIPFSUrl(url, chainId);
     }
     /**
-     * Fetch and process metadata from URI with IPFS conversion
+     * Fetch and process metadata from any URI with IPFS conversion.
+     *
+     * Use this for ad-hoc metadata fetching when you have a tokenURI.
+     * Normalization happens at infrastructure layer.
      */
     async fetchAndProcessMetadata(tokenUri, chainId) {
-        const domainMetadata = await this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
-        if (!domainMetadata)
-            return null;
-        // Convert from ERC token standard to our clean interface
-        const cleanMetadata = this.metadataMapper.fromERCStandard(domainMetadata);
-        // Add IPFS conversion if needed
-        if (cleanMetadata.animationUrl?.startsWith('ipfs://')) {
-            return {
-                ...cleanMetadata,
-                animationUrlConverted: await this.resolveIPFSUrl(cleanMetadata.animationUrl, chainId)
-            };
-        }
-        return cleanMetadata;
+        return this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
     }
 }
 
@@ -34434,7 +34548,7 @@ const useWeb3 = () => {
      *   chainId: 1
      * });
      * console.log('NFT name:', metadata?.name);
-     * console.log('NFT image:', metadata?.image);
+     * console.log('NFT image:', metadata?.imageUrl); // IPFS URLs auto-resolved to HTTPS
      * ```
      */
     const getTokenMetadata = react.useCallback(async (request) => {