dop-wallet-v6 1.2.12 → 1.2.14

package/SELECTIVE_TRANSPARENCY.md

@@ -0,0 +1,207 @@
+# Selective Transparency Feature
+
+The Selective Transparency feature allows DOP Wallet users to control the visibility of their assets, balances, NFTs, and profile information. Users can define privacy settings, manage whitelists, and generate cryptographic proofs for asset exposure.
+
+## Features
+
+### 1. User Profile Management
+- Create and manage user profiles with username, bio, profile picture, and social links
+- Profile customization with theme preferences and privacy alerts
+- Profile validation and search functionality
+
+### 2. Asset Visibility Control
+- Control visibility of token balances, NFTs, and transaction history
+- Granular control per token/NFT contract address
+- Global visibility settings with per-asset overrides
+
+### 3. Whitelist Management
+- Manage a list of trusted addresses that can view private information
+- Granular permissions for each whitelisted address
+- Support for viewing balances, NFTs, transactions, and profile data
+
+### 4. Viewing Requests & Proofs
+- Create and manage viewing requests from other users
+- Generate cryptographic proofs for authorized visibility
+- Proof verification and expiration management
+
+## Usage Examples
+
+### Profile Management
+
+```typescript
+import { ProfileManager } from 'dop-wallet-v3';
+
+const profileManager = new ProfileManager();
+
+// Create a user profile
+const profile = await profileManager.createProfile('wallet-id', {
+  username: 'alice',
+  bio: 'DeFi enthusiast',
+  profilePicture: 'https://example.com/avatar.jpg',
+  socialLinks: {
+    twitter: 'https://twitter.com/alice',
+    github: 'https://github.com/alice'
+  }
+});
+
+// Update profile
+await profileManager.updateProfile('wallet-id', {
+  bio: 'Privacy-focused DeFi user'
+});
+
+// Set profile customization
+await profileManager.setCustomization('wallet-id', {
+  theme: 'dark',
+  displayPreferences: {
+    currencyFormat: 'USD',
+    numberFormat: 'abbreviated',
+    dateFormat: 'MM/DD/YYYY',
+    timeFormat: '24h'
+  },
+  privacyAlerts: {
+    newViewingRequest: true,
+    profileUpdate: false,
+    assetVisibilityChange: true
+  }
+});
+```
+
+### Selective Transparency Settings
+
+```typescript
+import { SelectiveTransparencyManager } from 'dop-wallet-v3';
+
+const transparencyManager = new SelectiveTransparencyManager();
+
+// Create default privacy settings
+const settings = await transparencyManager.createDefaultSettings('wallet-id');
+
+// Update global visibility settings
+await transparencyManager.updateSettings('wallet-id', {
+  assetVisibility: {
+    showTokenBalances: false,  // Hide token balances by default
+    showNFTs: true,            // Show NFTs
+    showTransactionHistory: false, // Hide transaction history
+    showAddresses: false       // Hide addresses
+  }
+});
+
+// Set specific token visibility
+await transparencyManager.setTokenVisibility('wallet-id', '0x...tokenAddress', {
+  isVisible: true,
+  showBalance: true,
+  showTransactions: false
+});
+
+// Set NFT collection visibility
+await transparencyManager.setNFTVisibility('wallet-id', '0x...nftAddress', {
+  isVisible: true,
+  showCollection: true,
+  showTransactions: false
+});
+```
+
+### Whitelist Management
+
+```typescript
+// Add address to whitelist with specific permissions
+await transparencyManager.addToWhitelist('wallet-id', '0x...trustedAddress', {
+  viewBalances: true,
+  viewNFTs: true,
+  viewTransactions: false,
+  viewProfile: true
+});
+
+// Check if address has permission
+const canViewBalances = await transparencyManager.checkWhitelistPermission(
+  'wallet-id',
+  '0x...address',
+  'viewBalances'
+);
+
+// Remove from whitelist
+await transparencyManager.removeFromWhitelist('wallet-id', '0x...address');
+```
+
+### Viewing Requests & Proofs
+
+```typescript
+// Create a viewing request
+const request = await transparencyManager.createViewingRequest(
+  'requester-id',
+  'wallet-id',
+  'balance',
+  '0x...tokenAddress',
+  'Can I see your USDC balance?'
+);
+
+// Respond to viewing request
+await transparencyManager.respondToViewingRequest(request.id, 'approved');
+
+// Generate visibility proof (requires whitelist permission)
+const proof = await transparencyManager.generateVisibilityProof(
+  'wallet-id',
+  'requester-id',
+  'balance',
+  '0x...tokenAddress'
+);
+
+// Verify proof
+const isValid = await transparencyManager.verifyVisibilityProof(proof.id);
+```
+
+### Event Handling
+
+```typescript
+import { setSelectiveTransparencyCallback } from 'dop-wallet-v3';
+
+// Set up event listener
+setSelectiveTransparencyCallback((event) => {
+  switch (event.type) {
+    case 'profile_updated':
+      console.log('Profile updated for wallet:', event.data.walletId);
+      break;
+    case 'settings_changed':
+      console.log('Privacy settings changed for wallet:', event.data.walletId);
+      break;
+    case 'viewing_request':
+      console.log('New viewing request:', event.data);
+      break;
+    case 'proof_generated':
+      console.log('Visibility proof generated:', event.data);
+      break;
+  }
+});
+```
+
+## Security Features
+
+1. **Cryptographic Proofs**: All visibility proofs are cryptographically generated and time-limited
+2. **Whitelist-Only Proof Generation**: Only explicitly whitelisted addresses can generate visibility proofs
+3. **Granular Permissions**: Fine-grained control over what information each address can view
+4. **Expiration Management**: Viewing requests and proofs automatically expire
+5. **Validation**: All profile data and settings are validated before storage
+
+## Integration Notes
+
+- The feature is fully integrated into the main DOP Wallet SDK exports
+- All operations are asynchronous and return Promises
+- Profile and transparency managers maintain in-memory state (consider persisting to storage in production)
+- Event callbacks allow for real-time UI updates
+- All methods include proper error handling and sanitization
+
+## Testing
+
+The feature includes comprehensive unit tests covering:
+- Profile creation, updates, and validation
+- Privacy settings management
+- Token and NFT visibility controls
+- Whitelist management
+- Viewing request workflows
+- Visibility proof generation and verification
+- Error handling and edge cases
+
+Run tests with:
+```bash
+npm test -- --grep "ProfileManager|SelectiveTransparencyManager"
+```

package/WEB_WORKER_TROUBLESHOOTING.md

@@ -0,0 +1,180 @@
+# Web Worker Troubleshooting Guide for React Native
+
+## The Issue
+
+If you're seeing this error:
+```
+ERROR  node_modules/web-worker/cjs/node.js: node_modules/web-worker/cjs/node.js:Invalid call at line 201: import(mod)
+```
+
+This occurs because the `web-worker` package contains Node.js-specific code that uses dynamic imports (`import()`), which are not supported in React Native's Metro bundler.
+
+## Root Cause
+
+The `web-worker` package is a dependency of `circomlibjs` (used by dop-wallet-v6 for cryptographic operations). Even though we provide polyfills, Metro is still trying to parse the original package files, causing the error.
+
+## Solution Steps
+
+### 1. Update Your Metro Configuration
+
+Ensure your `metro.config.js` includes the updated configuration with proper blocking:
+
+```javascript
+const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
+const path = require('path');
+
+const defaultConfig = getDefaultConfig(__dirname);
+
+const config = {
+  resolver: {
+    // Node.js core module aliases - CRITICAL for fixing ffjavascript dependencies
+    alias: {
+      // Primary Node.js modules required by ffjavascript
+      'os': require.resolve('./node-polyfills/os-polyfill.js'),
+      'crypto': require.resolve('crypto-browserify'),
+      'stream': require.resolve('stream-browserify'),
+      'buffer': require.resolve('buffer'),
+      'events': require.resolve('events'),
+      'util': require.resolve('util'),
+      'assert': require.resolve('assert'),
+      'process': require.resolve('process/browser'),
+      
+      // Additional modules that might be needed
+      'path': require.resolve('path-browserify'),
+      'url': require.resolve('url'),
+      'querystring': require.resolve('querystring-es3'),
+      'http': require.resolve('stream-http'),
+      'https': require.resolve('https-browserify'),
+      'zlib': require.resolve('browserify-zlib'),
+      
+      // Web Worker compatibility - CRITICAL: Block the problematic package
+      'web-worker': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      'web-worker/cjs/node.js': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      'web-worker/cjs/node': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      
+      // Disable problematic WASM-related modules for React Native
+      'wasmcurves': require.resolve('./node-polyfills/wasm-fallback.js'),
+      'wasmbuilder': require.resolve('./node-polyfills/wasm-fallback.js'),
+    },
+    
+    // Extra node modules for Metro resolver
+    extraNodeModules: {
+      'os': require.resolve('./node-polyfills/os-polyfill.js'),
+      'crypto': require.resolve('crypto-browserify'),
+      'stream': require.resolve('stream-browserify'),
+      'buffer': require.resolve('buffer'),
+      'events': require.resolve('events'),
+      'util': require.resolve('util'),
+      'assert': require.resolve('assert'),
+      'process': require.resolve('process/browser'),
+      'path': require.resolve('path-browserify'),
+      'url': require.resolve('url'),
+      'querystring': require.resolve('querystring-es3'),
+      'http': require.resolve('stream-http'),
+      'https': require.resolve('https-browserify'),
+      'zlib': require.resolve('browserify-zlib'),
+      'web-worker': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      'wasmcurves': require.resolve('./node-polyfills/wasm-fallback.js'),
+      'wasmbuilder': require.resolve('./node-polyfills/wasm-fallback.js'),
+    },
+    
+    // Platforms - ensure React Native takes precedence
+    platforms: ['native', 'react-native', 'android', 'ios', 'web'],
+    
+    // Asset extensions - include WASM if needed (though we're disabling it)
+    assetExts: [...defaultConfig.resolver.assetExts, 'wasm'],
+    
+    // Source extensions - ensure TypeScript and JavaScript are handled
+    sourceExts: [...defaultConfig.resolver.sourceExts, 'cjs'],
+    
+    // Block problematic modules from being processed by Metro
+    blockList: [
+      // Block the original web-worker package to prevent dynamic import errors
+      /node_modules\/web-worker\/cjs\/node\.js$/,
+      /node_modules\/web-worker\/lib\/node\.js$/,
+      // Block other potential problematic files
+      /.*\/node_modules\/web-worker\/.*\.node$/,
+    ],
+  },
+  
+  transformer: {
+    // Disable minification for debugging if needed
+    minifierConfig: {
+      keep_fnames: true,
+      mangle: {
+        keep_fnames: true,
+      },
+    },
+  },
+};
+
+module.exports = mergeConfig(defaultConfig, config);
+```
+
+### 2. Copy Updated Polyfills
+
+Ensure you have copied the latest polyfill files from `new-dop-wallet-v3/node-polyfills/` to your React Native project root:
+
+- `os-polyfill.js`
+- `web-worker-polyfill.js` (updated version)
+- `wasm-fallback.js`
+
+### 3. Clear Metro Cache
+
+After updating the configuration, clear Metro's cache:
+
+```bash
+npx react-native start --reset-cache
+```
+
+### 4. Alternative Solution: Package Resolution Override
+
+If the above doesn't work, you can also try adding package resolution overrides to your `package.json`:
+
+```json
+{
+  "name": "your-react-native-app",
+  "dependencies": {
+    // ... your dependencies
+  },
+  "resolutions": {
+    "web-worker": "file:./node-polyfills/web-worker-polyfill.js"
+  },
+  "overrides": {
+    "web-worker": "file:./node-polyfills/web-worker-polyfill.js"
+  }
+}
+```
+
+### 5. Verification
+
+To verify the fix is working:
+
+1. Start Metro with cache reset: `npx react-native start --reset-cache`
+2. Run your app: `npx react-native run-android` or `npx react-native run-ios`
+3. Check that you see the polyfill warning instead of the error:
+   ```
+   Web Worker polyfill: Web Workers are not supported in React Native. Operations will run synchronously.
+   ```
+
+## Why This Happens
+
+1. **Dynamic imports**: The `web-worker` package uses `import()` syntax which Metro cannot process
+2. **Node.js specific code**: The package contains code designed for Node.js environments
+3. **Dependency chain**: Even though you don't directly use web-worker, it's pulled in by circomlibjs
+
+## Prevention
+
+- Always use the provided Metro configuration when integrating dop-wallet-v6
+- Copy all polyfill files, not just the ones you think you need
+- Test with cache reset after any configuration changes
+
+## Still Having Issues?
+
+If you're still experiencing problems:
+
+1. Check that your Metro configuration exactly matches the example
+2. Verify all polyfill files are copied to the correct location
+3. Ensure the paths in your Metro config point to the actual polyfill files
+4. Try deleting `node_modules` and reinstalling
+5. Check that you're not importing dop-wallet-v6 before the required shims

package/issuev3.md

@@ -0,0 +1,78 @@
+Integrating dop-wallet-v6 into a React Native 0.81 (new architecture) app consistently fails during Metro bundling before the app can run. All failures vanish if dop-wallet-v6 is removed. The errors originate from transitive deps brought in by dop-wallet-v6 (notably ffjavascript, web-worker, wasmcurves, wasmbuilder) that expect Node.js or Web Worker environments. React Native’s Metro/Hermes does not provide those environments by default.
+
+Key blockers observed:
+
+• ffjavascript does require('os') → Metro can’t resolve Node core module os.
+• After stubbing/aliasing os, Metro hits web-worker/cjs/node.js and fails on import(mod) (dynamic import in CJS path), which is incompatible in this RN+Metro context.
+• Prior to this, we also had to polyfill other Node core modules (assert, events, process, buffer) just to progress to the next error.
+When dop-wallet-v6 is uninstalled (and its import commented out), the app runs normally.
+
+ 
+Environment
+
+• Platform: React Native 0.81.x (New Architecture enabled)
+• Bundler/Engine: Metro + Hermes (RN default)
+• OS/Dev machine: macOS (Intel)
+• Crypto/Polyfills used in app:
+o react-native-quick-crypto (polyfills Node crypto)
+o react-native-get-random-values
+o Manual/global polyfills for process, Buffer, stream, util, assert, events
+o Local “os” stub (details below)
+Note: RN ≥0.76 no longer ships Node polyfills automatically. Metro requires explicit polyfills or aliases for Node core modules.
+
+Some Code Snippets
+
+Added polyfills.js and import it at the very top of index.js:
+// polyfills.js
+import 'react-native-get-random-values';
+import 'react-native-quick-crypto';
+ 
+if (typeof global.process === 'undefined') global.process = require('process');
+if (typeof global.Buffer === 'undefined') global.Buffer = require('buffer').Buffer;
+ 
+// Minimal 'os' ponyfill to get past ffjavascript's 'require("os")'
+// (Note: a global doesn’t satisfy require('os'); see metro alias below)
+global.os = {
+ platform: () => 'react-native',
+ homedir: () => '/',
+ tmpdir: () => '/tmp',
+};
+ 
+global.stream = require('stream-browserify');
+global.util = require('util');
+global.assert = require('assert');
+global.events = require('events');
+
+In metro.config.js, alias Node core os to our stub (this is what actually satisfies require('os') at bundle-time):
+// force `require('os')` to hit our stub file
+   os: require.resolve('./polyfills.js'),
+
+ 
+Errors & Logs
+➢ Missing Node core module (os):
+BUNDLE  ./index.js
+ERROR  Error: Unable to resolve module os from node_modules/ffjavascript/build/main.cjs:
+os could not be found within the project or in these directories: node_modules
+ 
+ 3 | var crypto = require('crypto');
+ 4 | var wasmcurves = require('wasmcurves');
+> 5 | var os = require('os');
+     ^
+ 6 | var Worker = require('web-worker');
+• Root: ffjavascript requires the Node core module os.
+• Workaround tried:
+• Setting global.os = { ... } alone is not enough because require('os') needs a module, not a global.
+• Aliasing os to a local stub in metro.config.js resolves bundling past this point.
+ 
+
+ 
+
+➢ Next blocker from web-worker:
+ERROR node_modules/web-worker/cjs/node.js: node_modules/web-worker/cjs/node.js: Invalid call at line 201: import(mod)
+
+Analysis (why this breaks on RN)
+
+1. Node core deps in transitive packages (ffjavascript → require('os')) aren’t available in RN. We can alias some, but it’s brittle and incomplete.
+2. Web Worker dependency (web-worker, wasmbuilder) assumes either Node (worker threads / dynamic loading) or browser (DOM Workers). React Native has neither by default. Metro/Hermes do not support those code paths out of the box.
+3. Dynamic import in a CJS Node path (web-worker/cjs/node.js → import(mod)) is not compatible with RN/Metro bundle stage in this context.
+4. Potential WASM assets (wasmcurves, wasmbuilder) usually require Metro config for *.wasm and a runtime that supports WASM in Hermes (partial/experimental). Even if we get past web-worker, WASM loading likely becomes the next blocker unless the SDK ships an RN-ready path.

package/metro.config.react-native.example.js

@@ -34,8 +34,10 @@ const config = {
       'https': require.resolve('https-browserify'),
       'zlib': require.resolve('browserify-zlib'),
       
-      // Web Worker compatibility - redirect to React Native compatible version
+      // Web Worker compatibility - CRITICAL: Block the problematic package
       'web-worker': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      'web-worker/cjs/node.js': require.resolve('./node-polyfills/web-worker-polyfill.js'),
+      'web-worker/cjs/node': require.resolve('./node-polyfills/web-worker-polyfill.js'),
       
       // Disable problematic WASM-related modules for React Native
       'wasmcurves': require.resolve('./node-polyfills/wasm-fallback.js'),
@@ -71,6 +73,15 @@ const config = {
     
     // Source extensions - ensure TypeScript and JavaScript are handled
     sourceExts: [...defaultConfig.resolver.sourceExts, 'cjs'],
+    
+    // Block problematic modules from being processed by Metro
+    blockList: [
+      // Block the original web-worker package to prevent dynamic import errors
+      /node_modules\/web-worker\/cjs\/node\.js$/,
+      /node_modules\/web-worker\/lib\/node\.js$/,
+      // Block other potential problematic files
+      /.*\/node_modules\/web-worker\/.*\.node$/,
+    ],
   },
   
   transformer: {

package/node-polyfills/os-polyfill.js

@@ -0,0 +1,130 @@
+/**
+ * OS module polyfill for React Native
+ * 
+ * This addresses the specific error:
+ * "Error: Unable to resolve module os from node_modules/ffjavascript/build/main.cjs"
+ * 
+ * ffjavascript uses os.platform() and other OS-specific functions.
+ * This polyfill provides React Native compatible alternatives.
+ */
+
+module.exports = {
+  /**
+   * Returns the operating system platform
+   * @returns {string} Always returns 'react-native' to indicate React Native environment
+   */
+  platform: () => 'react-native',
+  
+  /**
+   * Returns the platform-specific end-of-line marker
+   * @returns {string} Always returns '\n' for consistency
+   */
+  EOL: '\n',
+  
+  /**
+   * Returns the home directory path (stubbed for React Native)
+   * @returns {string} Returns a placeholder since React Native doesn't have home directories
+   */
+  homedir: () => '/react-native-home',
+  
+  /**
+   * Returns the temporary directory path (stubbed for React Native)
+   * @returns {string} Returns a placeholder since React Native handles temp differently
+   */
+  tmpdir: () => '/react-native-tmp',
+  
+  /**
+   * Returns hostname (stubbed for React Native)
+   * @returns {string} Returns a placeholder hostname
+   */
+  hostname: () => 'react-native-device',
+  
+  /**
+   * Returns the operating system type (stubbed for React Native)
+   * @returns {string} Always returns 'ReactNative'
+   */
+  type: () => 'ReactNative',
+  
+  /**
+   * Returns the operating system release (stubbed for React Native)
+   * @returns {string} Returns a placeholder version
+   */
+  release: () => '1.0.0',
+  
+  /**
+   * Returns system uptime (stubbed for React Native)
+   * @returns {number} Returns a placeholder uptime in seconds
+   */
+  uptime: () => 1000,
+  
+  /**
+   * Returns load averages (stubbed for React Native)
+   * @returns {number[]} Returns placeholder load averages
+   */
+  loadavg: () => [0, 0, 0],
+  
+  /**
+   * Returns total system memory (stubbed for React Native)
+   * @returns {number} Returns placeholder memory amount in bytes
+   */
+  totalmem: () => 1073741824, // 1GB placeholder
+  
+  /**
+   * Returns free system memory (stubbed for React Native)
+   * @returns {number} Returns placeholder free memory amount in bytes
+   */
+  freemem: () => 536870912, // 512MB placeholder
+  
+  /**
+   * Returns CPU information (stubbed for React Native)
+   * @returns {Object[]} Returns placeholder CPU info
+   */
+  cpus: () => [
+    {
+      model: 'React Native CPU',
+      speed: 2000,
+      times: {
+        user: 100,
+        nice: 0,
+        sys: 50,
+        idle: 1000,
+        irq: 0
+      }
+    }
+  ],
+  
+  /**
+   * Returns network interfaces (stubbed for React Native)
+   * @returns {Object} Returns placeholder network interface info
+   */
+  networkInterfaces: () => ({
+    'react-native': [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8'
+      }
+    ]
+  }),
+  
+  /**
+   * Returns system architecture (stubbed for React Native)
+   * @returns {string} Returns a placeholder architecture
+   */
+  arch: () => 'react-native',
+  
+  /**
+   * Returns user info (stubbed for React Native)
+   * @returns {Object} Returns placeholder user info
+   */
+  userInfo: () => ({
+    uid: -1,
+    gid: -1,
+    username: 'react-native-user',
+    homedir: '/react-native-home',
+    shell: null
+  })
+};

package/node-polyfills/wasm-fallback.js

@@ -0,0 +1,35 @@
+/**
+ * WASM fallback for React Native
+ * 
+ * This provides fallbacks for wasmcurves and wasmbuilder packages
+ * that are incompatible with React Native's JavaScript engine.
+ * 
+ * These packages are used by ffjavascript for optimized curve operations,
+ * but circomlibjs should fall back to pure JavaScript implementations
+ * when WASM is not available.
+ */
+
+console.warn('WASM fallback: WebAssembly operations will use JavaScript implementations in React Native.');
+
+// Mock the wasmcurves/wasmbuilder exports
+module.exports = {
+  // Mock curve operations - these should not be called if circomlibjs is properly configured
+  bn128: {
+    Fr: null,
+    G1: null,
+    G2: null,
+  },
+  
+  // Mock WASM builder - these should not be called if circomlibjs is properly configured
+  buildBn128: () => {
+    throw new Error('WASM curve operations not supported in React Native. Ensure circomlibjs is using JavaScript fallbacks.');
+  },
+  
+  // Mock any other common exports
+  buildBls12381: () => {
+    throw new Error('WASM curve operations not supported in React Native. Ensure circomlibjs is using JavaScript fallbacks.');
+  }
+};
+
+// Also support default export
+module.exports.default = module.exports;