toss-expo-sdk 1.0.1 → 1.0.4

package/src/index.tsx

@@ -45,6 +45,7 @@ export {
   processIntentsForSync,
   filterExpiredIntents,
 } from './intentManager';
+export { verifyIntent } from './intent';
 
 // Storage
 export {
@@ -52,6 +53,15 @@ export {
   getPendingIntents,
   clearPendingIntents,
 } from './storage';
+// Secure storage (hardware-backed)
+export {
+  secureStoreIntent,
+  getSecureIntent,
+  getAllSecureIntents,
+  removeSecureIntent,
+  clearAllSecureIntents,
+  cleanupExpiredIntents,
+} from './storage/secureStorage';
 
 // Transport methods (enhanced with fragmentation)
 export {
@@ -66,7 +76,10 @@ export { initNFC, readNFCUser, writeUserToNFC, writeIntentToNFC } from './nfc';
 export { QRScanner } from './qr';
 
 // Client
-export { TossClient, type TossConfig } from './client/TossClient';
+import { TossClient, type TossConfig } from './client/TossClient';
+export { TossClient, type TossConfig };
+// Convenience helper for createClient (matches README)
+export const createClient = TossClient.createClient;
 export type { TossUser } from './types/tossUser';
 export { WalletProvider, useWallet } from './contexts/WalletContext';
 
@@ -101,3 +114,15 @@ export {
   type IntentExchangeRequest,
   type IntentExchangeResponse,
 } from './discovery';
+
+// Compression utilities
+export {
+  compressMetadata,
+  decompressMetadata,
+  compressIntentMetadata,
+  decompressIntentMetadata,
+  estimateCompressionSavings,
+} from './utils/compression';
+
+// WiFi Direct transport
+export { WiFiDirectTransport, SmartTransportSelector } from './wifi';

package/src/qr.tsx

@@ -16,10 +16,10 @@ export function QRScanner({ onScan }: QRScannerProps) {
   const permission = useCameraPermission();
 
   const codeScanner = useCodeScanner({
-    codeTypes: ['qr'], // ✅ correct CodeType
+    codeTypes: ['qr'], //  correct CodeType
     onCodeScanned: (codes: Code[]) => {
       const code = codes[0];
-      if (!code?.value) return; // ✅ undefined-safe
+      if (!code?.value) return; //  undefined-safe
 
       onScan(code.value);
     },

package/src/reconciliation.ts

@@ -343,7 +343,7 @@ export async function submitTransactionToArciumMXE(
       provider
     );
 
-    msg?.('🔐 Intent parameters encrypted with Arcium MXE');
+    msg?.(' Intent parameters encrypted with Arcium MXE');
 
     // PRODUCTION: Build MXE submission instruction
     // Per TOSS Paper Section 7: "Arcium operates strictly before onchain execution"
@@ -371,7 +371,7 @@ export async function submitTransactionToArciumMXE(
     ]);
 
     msg?.(
-      '🔐 Encrypted data prepared for MXE program (size: ' +
+      ' Encrypted data prepared for MXE program (size: ' +
         encryptedDataBuffer.length +
         ' bytes)'
     );
@@ -393,7 +393,7 @@ export async function submitTransactionToArciumMXE(
     };
 
     msg?.(
-      '📤 Submitting encrypted intent to MXE program for confidential execution'
+      ' Submitting encrypted intent to MXE program for confidential execution'
     );
 
     // PRODUCTION: Build transaction with MXE instruction
@@ -421,7 +421,7 @@ export async function submitTransactionToArciumMXE(
       maxRetries
     );
 
-    msg?.('✅ MXE transaction submitted - encrypted execution in progress');
+    msg?.(' MXE transaction submitted - encrypted execution in progress');
     msg?.('   Signature: ' + mxeSignature);
     msg?.('   Intent details remain confidential until settlement');
 

package/src/services/authService.ts

@@ -166,7 +166,7 @@ export class AuthService {
   ): Promise<void> {
     if (!useBiometrics) {
       throw new Error(
-        '❌ SECURITY ERROR: Biometric protection is mandatory for wallet security'
+        ' SECURITY ERROR: Biometric protection is mandatory for wallet security'
       );
     }
 
@@ -176,7 +176,7 @@ export class AuthService {
 
     if (!hasHardware || !isEnrolled) {
       throw new Error(
-        '❌ Biometric authentication required but not configured on device'
+        ' Biometric authentication required but not configured on device'
       );
     }
 
@@ -264,7 +264,7 @@ export class AuthService {
 
     if (!hasHardware || !isEnrolled) {
       throw new Error(
-        '❌ Biometric authentication required but not configured on this device'
+        ' Biometric authentication required but not configured on this device'
       );
     }
 

package/src/utils/compression.ts

@@ -0,0 +1,247 @@
+/**
+ * Compression Utilities for TOSS
+ *
+ * Implements safe, deterministic compression for metadata only.
+ * Transaction bytes are NEVER compressed to preserve determinism.
+ *
+ * Production-ready with official APIs.
+ */
+
+import { Buffer } from 'buffer';
+
+/**
+ * Simple DEFLATE-based compression using native zlib
+ * (Available in Node.js and via polyfills in React Native)
+ *
+ * For metadata compression: memos, recipient names, etc.
+ * NOT for transaction signatures or amounts!
+ */
+export interface CompressionResult {
+  compressed: boolean;
+  data: Uint8Array;
+  originalSize: number;
+  compressedSize: number;
+  compressionRatio: number;
+}
+
+/**
+ * Compress metadata safely
+ * Only compresses if compression saves >10% and data >200 bytes
+ *
+ * Safe for: memo text, user names, descriptions
+ * UNSAFE for: signatures, amounts, transaction data
+ */
+export async function compressMetadata(
+  data: string
+): Promise<CompressionResult> {
+  try {
+    const originalBuffer = Buffer.from(data, 'utf-8');
+    const originalSize = originalBuffer.length;
+
+    // Only compress if it's worth it
+    if (originalSize < 200) {
+      return {
+        compressed: false,
+        data: new Uint8Array(originalBuffer),
+        originalSize,
+        compressedSize: originalSize,
+        compressionRatio: 1.0,
+      };
+    }
+
+    // Use native compression if available (Node.js)
+    // For React Native, this will use a polyfill
+    const zlib = await importZlib();
+
+    const compressed = await new Promise<Buffer>((resolve, reject) => {
+      zlib.deflate(originalBuffer, (err: any, result: Buffer) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    });
+
+    const compressedSize = compressed.length;
+    const compressionRatio = compressedSize / originalSize;
+
+    // Only use compression if it saves >10%
+    if (compressionRatio > 0.9) {
+      return {
+        compressed: false,
+        data: new Uint8Array(originalBuffer),
+        originalSize,
+        compressedSize: originalSize,
+        compressionRatio: 1.0,
+      };
+    }
+
+    return {
+      compressed: true,
+      data: new Uint8Array(compressed),
+      originalSize,
+      compressedSize,
+      compressionRatio,
+    };
+  } catch (error) {
+    // Graceful fallback: if compression fails, return uncompressed
+    console.warn('Compression failed, returning uncompressed:', error);
+    const buffer = Buffer.from(data, 'utf-8');
+    return {
+      compressed: false,
+      data: new Uint8Array(buffer),
+      originalSize: buffer.length,
+      compressedSize: buffer.length,
+      compressionRatio: 1.0,
+    };
+  }
+}
+
+/**
+ * Decompress metadata
+ */
+export async function decompressMetadata(data: Uint8Array): Promise<string> {
+  try {
+    const zlib = await importZlib();
+
+    const decompressed = await new Promise<Buffer>((resolve, reject) => {
+      zlib.inflate(Buffer.from(data), (err: any, result: Buffer) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    });
+
+    return decompressed.toString('utf-8');
+  } catch (error) {
+    console.warn('Decompression failed:', error);
+    // Assume data was not compressed
+    return Buffer.from(data).toString('utf-8');
+  }
+}
+
+/**
+ * Compress intent metadata for efficient transmission
+ * Returns the original intent with compressed metadata
+ */
+export async function compressIntentMetadata(
+  intentMetadata: Record<string, any>
+): Promise<{
+  original: Record<string, any>;
+  compressed: Record<string, any>;
+  savings: number;
+}> {
+  const compressed: Record<string, any> = {};
+  let totalOriginal = 0;
+  let totalCompressed = 0;
+
+  for (const [key, value] of Object.entries(intentMetadata)) {
+    if (typeof value === 'string') {
+      const result = await compressMetadata(value);
+      totalOriginal += result.originalSize;
+      totalCompressed += result.compressedSize;
+
+      if (result.compressed) {
+        compressed[key] = {
+          __compressed: true,
+          data: Array.from(result.data),
+        };
+      } else {
+        compressed[key] = value;
+      }
+    } else {
+      compressed[key] = value;
+    }
+  }
+
+  const savings =
+    totalOriginal > 0 ? ((totalOriginal - totalCompressed) / totalOriginal) * 100 : 0;
+
+  return {
+    original: intentMetadata,
+    compressed,
+    savings: Math.round(savings),
+  };
+}
+
+/**
+ * Decompress intent metadata
+ */
+export async function decompressIntentMetadata(
+  compressedMetadata: Record<string, any>
+): Promise<Record<string, any>> {
+  const decompressed: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(compressedMetadata)) {
+    if (
+      typeof value === 'object' &&
+      value !== null &&
+      value.__compressed === true
+    ) {
+      const buffer = new Uint8Array(value.data);
+      decompressed[key] = await decompressMetadata(buffer);
+    } else {
+      decompressed[key] = value;
+    }
+  }
+
+  return decompressed;
+}
+
+/**
+ * Lazy-load zlib to avoid breaking in environments without it
+ */
+async function importZlib(): Promise<any> {
+  // In Node.js, use native zlib
+  if (typeof require !== 'undefined') {
+    try {
+      return require('zlib');
+    } catch {
+      // Fall through to polyfill
+    }
+  }
+
+  // For React Native, try to use a polyfill
+  // This can be pako (pako-zlib) or similar
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const pako = await import('pako' as string) as any;
+    return {
+      deflate: (data: Buffer, callback: any) => {
+        try {
+          const compressed = pako.deflate(data);
+          callback(null, Buffer.from(compressed));
+        } catch (err) {
+          callback(err);
+        }
+      },
+      inflate: (data: Buffer, callback: any) => {
+        try {
+          const decompressed = pako.inflate(data);
+          callback(null, Buffer.from(decompressed));
+        } catch (err) {
+          callback(err);
+        }
+      },
+    };
+  } catch {
+    throw new Error(
+      'Compression not available in this environment. Install pako or use Node.js.'
+    );
+  }
+}
+
+/**
+ * Calculate size savings for a metadata object
+ */
+export function estimateCompressionSavings(
+  metadata: Record<string, any>
+): number {
+  let totalSize = 0;
+
+  for (const value of Object.values(metadata)) {
+    if (typeof value === 'string') {
+      totalSize += value.length;
+    }
+  }
+
+  // Conservative estimate: ~35% savings on text (typical for DEFLATE)
+  return Math.round(totalSize * 0.35);
+}