@spacesops/wdk-react-native-core 1.0.0-beta.69 → 1.0.0-beta.71

package/dist/utils/utils/schemas.js

@@ -1,173 +0,0 @@
-/**
- * Zod Schemas for Runtime Validation
- *
- * Provides Zod schemas for all WDK types to replace manual if/else type guards.
- * These schemas provide better error messages and are easier to maintain.
- */
-import { z } from 'zod';
-/**
- * Ethereum address schema (0x followed by 40 hex characters)
- */
-export const ethereumAddressSchema = z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
-    message: 'Must be a valid Ethereum address (0x followed by 40 hex characters)',
-});
-/**
- * Token contract address schema — EVM, TON, Tron, Solana, and other worklet-supported formats.
- * Wallet receive addresses use {@link addressSchema}; token mint/contract IDs are chain-specific.
- */
-export const tokenContractAddressSchema = z.union([
-    ethereumAddressSchema,
-    z.string().regex(/^T[1-9A-HJ-NP-Za-km-z]{33}$/, {
-        message: 'Must be a valid Tron token contract address',
-    }),
-    z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/, {
-        message: 'Must be a valid Solana token mint address',
-    }),
-    z.string().regex(/^(EQ|UQ)[A-Za-z0-9_-]{46}$/, {
-        message: 'Must be a valid TON jetton master address',
-    }),
-]);
-/**
- * Spark address schema (Bech32 format: spark1/sparkt1/sparkrt1 followed by base32 characters)
- */
-export const sparkAddressSchema = z.string().regex(/^spark(1|t1|rt1|test1)[a-z0-9]+$/, {
-    message: 'Must be a valid Spark address (spark1/sparkt1/sparkrt1 followed by base32 characters)',
-}).min(14).max(90);
-/**
- * Bitcoin address schema — mainnet/testnet/regtest bech32 (bc1/tb1/bcrt1) and legacy Base58.
- */
-export const bitcoinAddressSchema = z.string().regex(/^(bc1[qp][a-z0-9]{11,71}|tb1[qp][a-z0-9]{11,71}|bcrt1[qp][a-z0-9]{11,71}|[13][a-km-zA-HJ-NP-Z1-9]{25,34}|[mn2][a-km-zA-HJ-NP-Z1-9]{25,34})$/, {
-    message: 'Must be a valid Bitcoin address (bech32 bc1/tb1/bcrt1 or legacy Base58)',
-});
-/**
- * Address schema (Ethereum, Spark, or Bitcoin)
- */
-export const addressSchema = z.union([ethereumAddressSchema, sparkAddressSchema, bitcoinAddressSchema]);
-/**
- * Network configuration schema
- */
-export const networkConfigSchema = z.object({
-    chainId: z.number().int().positive(),
-    blockchain: z.string().min(1),
-    provider: z.string().min(1).optional(),
-    bundlerUrl: z.string().min(1).optional(),
-    paymasterUrl: z.string().min(1).optional(),
-    paymasterAddress: ethereumAddressSchema.optional(),
-    entryPointAddress: ethereumAddressSchema.optional(),
-    transferMaxFee: z.number().nonnegative().optional(),
-});
-/**
- * Network configurations schema
- */
-export const networkConfigsSchema = z.record(z.string().regex(/^[a-zA-Z0-9_-]+$/, {
-    message: 'Network name must contain only alphanumeric characters, hyphens, and underscores',
-}), networkConfigSchema).refine((configs) => Object.keys(configs).length > 0, {
-    message: 'NetworkConfigs must contain at least one network',
-});
-/**
- * Token configuration schema
- */
-export const tokenConfigSchema = z.object({
-    symbol: z.string().min(1),
-    name: z.string().min(1),
-    decimals: z.number().int().min(0).max(18),
-    address: z.union([tokenContractAddressSchema, z.null()]),
-});
-/**
- * Network tokens schema
- */
-export const networkTokensSchema = z.object({
-    native: tokenConfigSchema,
-    tokens: z.array(tokenConfigSchema),
-});
-/**
- * Token configurations schema
- */
-export const tokenConfigsSchema = z.record(z.string().min(1), networkTokensSchema).refine((configs) => Object.keys(configs).length > 0, {
-    message: 'TokenConfigs must contain at least one network',
-});
-/**
- * Account index schema
- */
-export const accountIndexSchema = z.number().int().nonnegative();
-/**
- * Network name schema
- */
-export const networkNameSchema = z.string().regex(/^[a-zA-Z0-9_-]+$/, {
-    message: 'Network name must contain only alphanumeric characters, hyphens, and underscores',
-}).min(1);
-/**
- * Balance string schema (valid number string)
- */
-export const balanceStringSchema = z.string().regex(/^-?\d+(\.\d+)?$/, {
-    message: 'Balance must be a valid number string',
-});
-/**
- * Wallet addresses schema
- * Maps network -> accountIndex -> address
- */
-export const walletAddressesSchema = z.record(networkNameSchema, z.record(z.string().transform((val) => {
-    const num = parseInt(val, 10);
-    if (isNaN(num) || num < 0) {
-        throw new Error('Account index must be a non-negative integer');
-    }
-    return num;
-}), addressSchema));
-/**
- * Wallet balances schema
- * Maps network -> accountIndex -> tokenAddress -> balance
- */
-export const walletBalancesSchema = z.record(networkNameSchema, z.record(z.string().transform((val) => {
-    const num = parseInt(val, 10);
-    if (isNaN(num) || num < 0) {
-        throw new Error('Account index must be a non-negative integer');
-    }
-    return num;
-}), z.record(z.string(), balanceStringSchema)));
-/**
- * Balance loading states schema
- * Maps "network-accountIndex-tokenAddress" -> boolean
- */
-export const balanceLoadingStatesSchema = z.record(z.string(), z.boolean());
-/**
- * Balance fetch result schema
- */
-export const balanceFetchResultSchema = z.object({
-    success: z.boolean(),
-    network: networkNameSchema,
-    accountIndex: accountIndexSchema,
-    tokenAddress: z.union([tokenContractAddressSchema, z.null()]),
-    balance: z.union([balanceStringSchema, z.null()]),
-    error: z.string().optional(),
-});
-/**
- * Wallet schema
- */
-export const walletSchema = z.object({
-    accountIndex: accountIndexSchema,
-    identifier: z.string().min(1),
-    name: z.string().min(1),
-    createdAt: z.number().int().nonnegative(),
-    updatedAt: z.number().int().nonnegative(),
-});
-/**
- * Worklet response schemas for runtime validation
- */
-export const workletResponseSchema = z.object({
-    result: z.string(),
-    error: z.string().optional(),
-});
-/**
- * Balance response schema (numeric string)
- */
-export const balanceResponseSchema = z.string().regex(/^\d+$/, {
-    message: 'Balance must be a numeric string',
-});
-/**
- * Account method response schema (union of possible return types)
- */
-export const accountMethodResponseSchema = z.union([
-    balanceResponseSchema,
-    z.string(), // For addresses
-    z.object({}).passthrough(), // For other responses (objects)
-]);

package/dist/utils/utils/validation.js

@@ -1,151 +0,0 @@
-/**
- * Validation utilities for WDK provider props and inputs
- *
- * These functions throw errors for invalid inputs.
- * Uses Zod schemas for validation with better error messages.
- * For type guards (boolean returns), see typeGuards.ts
- */
-import { z } from 'zod';
-import { networkConfigsSchema, tokenConfigsSchema, accountIndexSchema, networkNameSchema, balanceStringSchema, tokenContractAddressSchema, } from './schemas';
-/**
- * Extract error message from Zod error
- */
-function getZodErrorMessage(error) {
-    if (error instanceof z.ZodError) {
-        // Get the first error message for simplicity
-        const firstIssue = error.issues[0];
-        if (firstIssue) {
-            return firstIssue.message;
-        }
-        return 'Validation failed';
-    }
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-/**
- * Validate network configuration
- */
-export function validateNetworkConfigs(networkConfigs) {
-    try {
-        networkConfigsSchema.parse(networkConfigs);
-    }
-    catch (error) {
-        throw new Error(`Invalid networkConfigs: ${getZodErrorMessage(error)}`);
-    }
-}
-/**
- * Validate token configuration
- */
-export function validateTokenConfigs(tokenConfigs) {
-    try {
-        tokenConfigsSchema.parse(tokenConfigs);
-    }
-    catch (error) {
-        throw new Error(`Invalid tokenConfigs: ${getZodErrorMessage(error)}`);
-    }
-}
-/**
- * Validate balance refresh interval
- */
-export function validateBalanceRefreshInterval(interval) {
-    if (interval !== undefined) {
-        if (typeof interval !== 'number') {
-            throw new Error('balanceRefreshInterval must be a number');
-        }
-        if (interval < 0) {
-            throw new Error('balanceRefreshInterval must be a non-negative number');
-        }
-        if (!Number.isFinite(interval)) {
-            throw new Error('balanceRefreshInterval must be a finite number');
-        }
-    }
-}
-/**
- * Validate that an object has required methods
- *
- * @param obj - Object to validate
- * @param requiredMethods - Array of required method names
- * @param objectName - Name of the object for error messages
- */
-export function validateRequiredMethods(obj, requiredMethods, objectName) {
-    if (!obj || typeof obj !== 'object') {
-        throw new Error(`${objectName} must be an object`);
-    }
-    for (const methodName of requiredMethods) {
-        if (typeof obj[methodName] !== 'function') {
-            throw new Error(`${objectName} must have a ${methodName} method`);
-        }
-    }
-}
-/**
- * Validate account index
- */
-export function validateAccountIndex(accountIndex) {
-    try {
-        accountIndexSchema.parse(accountIndex);
-    }
-    catch (error) {
-        const message = getZodErrorMessage(error);
-        throw new Error(`Invalid accountIndex: ${message}`);
-    }
-}
-/**
- * Validate network name
- */
-export function validateNetworkName(network) {
-    try {
-        networkNameSchema.parse(network);
-    }
-    catch (error) {
-        const message = getZodErrorMessage(error);
-        // Provide a fallback message if Zod error doesn't have a clear message
-        if (message === 'Validation failed' || !message) {
-            throw new Error('network must be a non-empty string containing only alphanumeric characters, hyphens, and underscores');
-        }
-        throw new Error(`Invalid network name: ${message}`);
-    }
-}
-/**
- * Validate token address (can be null for native tokens)
- */
-export function validateTokenAddress(tokenAddress) {
-    if (tokenAddress === null) {
-        return;
-    }
-    try {
-        tokenContractAddressSchema.parse(tokenAddress);
-    }
-    catch (error) {
-        const message = getZodErrorMessage(error);
-        throw new Error(`Invalid tokenAddress: ${message}`);
-    }
-}
-/**
- * Validate balance string
- */
-export function validateBalance(balance) {
-    try {
-        balanceStringSchema.parse(balance);
-    }
-    catch (error) {
-        const message = getZodErrorMessage(error);
-        throw new Error(`Invalid balance: ${message}`);
-    }
-}
-/**
- * Validate wallet parameters (network, accountIndex, optional tokenAddress)
- * Convenience function to validate common wallet operation parameters
- *
- * @param network - Network name
- * @param accountIndex - Account index
- * @param tokenAddress - Optional token address (null for native tokens)
- */
-export function validateWalletParams(network, accountIndex, tokenAddress) {
-    validateNetworkName(network);
-    validateAccountIndex(accountIndex);
-    if (tokenAddress !== undefined) {
-        validateTokenAddress(tokenAddress);
-    }
-}