commit 6f1d6ec37b95364dfc55a15303ede0e297d0f7e2
Author: Chris Daßler <chris.dassler@me.com>
Date:   Fri Aug 29 11:18:37 2025 +0200

    Initial commit: libp2p-native-bridge package
    
    - Extracted libp2p component from main app
    - Created modular package structure with interfaces and implementations
    - Added dependency injection for NativeModules
    - Configured for IOR loading from Gitea
    - Added comprehensive README and documentation

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..53e7358
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,237 @@
+# Created by https://www.toptal.com/developers/gitignore/api/macos,windows,linux,visualstudiocode,node
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos,windows,linux,visualstudiocode,node
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+### Node Patch ###
+# Serverless Webpack directories
+.webpack/
+
+# Optional stylelint cache
+
+# SvelteKit build / generate output
+.svelte-kit
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/macos,windows,linux,visualstudiocode,node
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..7052196
--- /dev/null
+++ b/README.md
@@ -0,0 +1,233 @@
+# libp2p-native-bridge
+
+Native libp2p bridge for React Native applications, providing a unified interface for iOS and Android libp2p implementations.
+
+## Installation
+
+### Via IOR (Interoperable Object Reference)
+
+```typescript
+import { Libp2pComponent } from 'ior:gitea:gitea.metatrom.net:universal-components/libp2p-native-bridge@1.0.0';
+```
+
+### Via npm/yarn (if published)
+
+```bash
+npm install @metatrom/libp2p-native-bridge
+# or
+yarn add @metatrom/libp2p-native-bridge
+```
+
+## Features
+
+- 🌐 Unified libp2p interface for React Native
+- 📱 iOS and Android native module support
+- 🔧 Configurable settings management
+- 🎛️ Settings UI component
+- 🔌 Protocol handler support
+- 🔍 Peer discovery and connection management
+- 🚀 TypeScript support with full type definitions
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { Libp2pComponent } from '@metatrom/libp2p-native-bridge';
+
+// Create libp2p instance
+const libp2p = new Libp2pComponent({
+  config: {
+    tcpPort: 10000,
+    wsPort: 10005,
+  },
+  protocols: [
+    {
+      protocolId: '/my-protocol/1.0.0',
+      handler: async ({ peerId, data }) => {
+        console.log(`Received data from ${peerId}:`, data);
+      },
+    },
+  ],
+});
+
+// Start the node
+await libp2p.start();
+
+// Listen for peer discovery
+libp2p.addEventListener('peer:discovery', (evt) => {
+  console.log('Discovered peer:', evt.detail.id.toString());
+});
+
+// Connect to a peer
+await libp2p.dial('/ip4/192.168.1.2/tcp/10000/p2p/12D3KooW...');
+```
+
+### Using with React Hook
+
+```typescript
+import { useLibp2p } from './hooks/useLibp2p';
+import { Libp2pComponent } from '@metatrom/libp2p-native-bridge';
+
+function MyComponent() {
+  const { isStarted, peerId, discoveredPeers, start, stop } = useLibp2p({
+    config: {
+      tcpPort: 10000,
+      wsPort: 10005,
+    },
+  });
+
+  return (
+    <View>
+      <Text>Status: {isStarted ? 'Started' : 'Stopped'}</Text>
+      <Text>Peer ID: {peerId?.toString()}</Text>
+      <Button title="Start" onPress={start} />
+      <Button title="Stop" onPress={stop} />
+    </View>
+  );
+}
+```
+
+### Settings Management
+
+```typescript
+import { getSettingsService, SettingsUI } from '@metatrom/libp2p-native-bridge';
+
+// Get settings service instance
+const settingsService = getSettingsService();
+
+// Load settings
+const settings = await settingsService.loadSettings();
+
+// Update settings
+await settingsService.updateSetting('tcpPort', 10100);
+
+// Use the Settings UI component
+<SettingsUI
+  initialSettings={settings}
+  onSettingsChange={(newSettings) => {
+    console.log('Settings changed:', newSettings);
+  }}
+/>
+```
+
+## API Reference
+
+### Libp2pComponent
+
+Main class for interacting with the native libp2p implementation.
+
+#### Constructor Options
+
+```typescript
+interface Libp2pOptions {
+  config?: {
+    tcpPort?: number;    // Default: 10000
+    wsPort?: number;     // Default: 10005
+  };
+  protocols?: ProtocolHandler[];
+  keypair?: {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+  };
+}
+```
+
+#### Methods
+
+- `start()`: Start the libp2p node
+- `stop()`: Stop the libp2p node
+- `dial(multiaddr: string)`: Connect to a peer
+- `hangUp(peerId: string)`: Disconnect from a peer
+- `getConnections(peerId?: string)`: Get active connections
+- `sendProtocolData(peerId: string, protocolId: string, data: Uint8Array)`: Send data via protocol
+- `refreshDiscovery()`: Refresh peer discovery
+- `pingPeer(peerId: string)`: Ping a peer
+
+#### Events
+
+- `peer:discovery`: New peer discovered
+- `peer:lost`: Peer lost
+- `peer:connect`: Peer connected
+- `peer:disconnect`: Peer disconnected
+- `connection:open`: Connection opened
+- `connection:close`: Connection closed
+- `self:peer:update`: Own peer info updated
+
+### SettingsService
+
+Singleton service for managing application settings.
+
+#### Methods
+
+- `getInstance()`: Get singleton instance
+- `initialize()`: Initialize settings
+- `loadSettings()`: Load settings from storage
+- `saveSettings(settings)`: Save settings
+- `getSettings()`: Get current settings
+- `updateSetting(key, value)`: Update specific setting
+- `resetAllData()`: Reset all application data
+
+## Native Module Requirements
+
+This package requires the following native modules to be implemented in your React Native project:
+
+### iOS
+- `Libp2pModule`: Swift implementation of libp2p
+- `DiscoveryModule`: mDNS/Bonjour discovery
+- `SecureStorageModule`: Keychain storage (optional)
+
+### Android
+- `Libp2pModule`: Kotlin implementation of libp2p
+- `DiscoveryModule`: Network Service Discovery
+- `SecureStorageModule`: Keystore storage (optional)
+
+## Configuration
+
+### Default Settings
+
+```typescript
+{
+  tcpPort: 10000,
+  wsPort: 10005,
+  discoveryTimeout: 30000,
+  enableDebugLogs: false,
+  autoDiscovery: false,
+  useCustomPorts: false,
+  dhtServerUrl: 'ws://192.168.188.40:3000/ws'
+}
+```
+
+## Platform Considerations
+
+### iOS
+- Uses Swift libp2p packages
+- Native Bonjour/mDNS discovery
+- Compile-time protocol registration
+
+### Android
+- Uses Kotlin with JVM libp2p
+- Network Service Discovery (NSD)
+- Dynamic protocol registration
+
+## Dependencies
+
+### Peer Dependencies
+- `react`: >=18.0.0
+- `react-native`: >=0.72.0
+- `@react-native-async-storage/async-storage`: *
+
+### External IOR Dependencies
+- `ior:gitea:gitea.metatrom.net:universal-components/logger@1.0.0`
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues and questions, please open an issue on the repository.
\ No newline at end of file
diff --git a/implementations/Libp2pComponent.ts b/implementations/Libp2pComponent.ts
new file mode 100644
index 0000000..ef26d2b
--- /dev/null
+++ b/implementations/Libp2pComponent.ts
@@ -0,0 +1,402 @@
+/**
+ * Native libp2p bridge component for React Native
+ */
+
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import { LIBP2P_CONFIG } from '../utils/constants';
+import type { ConnectionStatusEvent, PeerDiscoveredEvent, PeerInfoEvent } from '../utils/types';
+import type {
+  Connection,
+  ILibp2pComponent,
+  Libp2pEvents,
+  Libp2pOptions,
+  Multiaddr,
+  PeerId,
+  PeerInfo,
+} from '../interfaces/ILibp2pComponent';
+
+// Helper class to create PeerId-like objects from strings
+export class SimplePeerId implements PeerId {
+  constructor(private id: string) {}
+
+  toString(): string {
+    return this.id;
+  }
+
+  toBytes(): Uint8Array {
+    return new TextEncoder().encode(this.id);
+  }
+
+  equals(other: PeerId): boolean {
+    return this.toString() === other.toString();
+  }
+}
+
+// Helper class to create Multiaddr-like objects from strings  
+export class SimpleMultiaddr implements Multiaddr {
+  bytes: Uint8Array;
+
+  constructor(private addr: string) {
+    this.bytes = new TextEncoder().encode(addr);
+  }
+
+  toString(): string {
+    return this.addr;
+  }
+
+  protos(): Array<{ code: number; name: string }> {
+    // Simple parsing of multiaddr components
+    const parts = this.addr.split('/').filter((p) => p);
+    const protos = [];
+
+    for (let i = 0; i < parts.length; i += 2) {
+      const name = parts[i];
+      protos.push({ code: 0, name }); // Simplified - real implementation would have proper codes
+    }
+
+    return protos;
+  }
+
+  getPeerId(): string | null {
+    const match = this.addr.match(/\/p2p\/([^/]+)/);
+    return match ? match[1] : null;
+  }
+}
+
+// Type for event handler functions
+type EventHandler<T = unknown> = (evt: T) => void;
+
+// Native implementation that wraps our iOS/Android modules
+export class Libp2pComponent implements ILibp2pComponent {
+  private nativeModule: any;
+  private eventEmitter: NativeEventEmitter;
+  private eventHandlers: Map<string, Set<EventHandler>> = new Map();
+  private _peerId?: PeerId;
+  private _multiaddrs: Multiaddr[] = [];
+  private _started: boolean = false;
+  private cachedConnections: Connection[] = [];
+  private options: Libp2pOptions;
+
+  constructor(options?: Libp2pOptions, nativeModules?: typeof NativeModules) {
+    // Allow dependency injection of NativeModules for testing
+    const modules = nativeModules || NativeModules;
+    this.nativeModule = modules.Libp2pModule;
+    this.eventEmitter = new NativeEventEmitter(this.nativeModule);
+    this.options = options || {};
+
+    if (!this.nativeModule) {
+      throw new Error('Libp2p native module not found');
+    }
+
+    this.setupNativeEventListeners();
+    this.setupProtocolHandlers();
+  }
+
+  get peerId(): PeerId | null {
+    return this._peerId || null;
+  }
+
+  get multiaddrs(): Multiaddr[] {
+    return this._multiaddrs;
+  }
+
+  private setupNativeEventListeners(): void {
+    // Map native events to js-libp2p style events
+
+    // Peer info update
+    this.eventEmitter.addListener('onPeerInfo', ({ peerId, multiaddrs }: PeerInfoEvent) => {
+      this._peerId = new SimplePeerId(peerId);
+      this._multiaddrs = multiaddrs.map((addr: string) => new SimpleMultiaddr(addr));
+      this.emit('self:peer:update', {
+        peerId: this._peerId,
+        multiaddrs: this._multiaddrs,
+      });
+    });
+
+    // Peer discovery
+    this.eventEmitter.addListener(
+      'onPeerDiscovered',
+      ({ peerId, addresses, multiaddrs }: PeerDiscoveredEvent) => {
+        const addrs = (multiaddrs || addresses || []).map(
+          (addr: string) => new SimpleMultiaddr(addr),
+        );
+        this.emit('peer:discovery', {
+          id: new SimplePeerId(peerId),
+          multiaddrs: addrs,
+        });
+      },
+    );
+
+    // Peer lost (for mDNS service lost events)
+    this.eventEmitter.addListener('onPeerLost', ({ peerId }: { peerId: string }) => {
+      this.emit('peer:lost', {
+        id: new SimplePeerId(peerId),
+      });
+    });
+
+    // Connection events
+    this.eventEmitter.addListener(
+      'onConnectionStatus',
+      ({ peerId, status, direction, multiaddr }: ConnectionStatusEvent) => {
+        const connection: Connection = {
+          id: `${peerId}-${Date.now()}`,
+          remotePeer: new SimplePeerId(peerId),
+          remoteAddr: new SimpleMultiaddr(multiaddr || ''),
+          stat: {
+            direction: direction || 'outbound',
+            status:
+              status === LIBP2P_CONFIG.CONNECTION_STATUS.CONNECTED
+                ? 'open'
+                : status === LIBP2P_CONFIG.CONNECTION_STATUS.PENDING
+                  ? 'pending'
+                  : status === LIBP2P_CONFIG.CONNECTION_STATUS.DISCONNECTED
+                    ? 'closed'
+                    : 'closing',
+            timeline: {
+              open: Date.now(),
+            },
+          },
+        };
+
+        if (
+          status === LIBP2P_CONFIG.CONNECTION_STATUS.CONNECTED ||
+          status === LIBP2P_CONFIG.CONNECTION_STATUS.PENDING
+        ) {
+          // Emit peer:connect for both pending and connected states
+          // The UI will differentiate based on connection.stat.status
+          this.emit('peer:connect', connection);
+          this.emit('connection:open', connection);
+        } else if (
+          status === LIBP2P_CONFIG.CONNECTION_STATUS.DISCONNECTED ||
+          status === LIBP2P_CONFIG.CONNECTION_STATUS.FAILED
+        ) {
+          connection.stat.timeline.close = Date.now();
+          connection.stat.status = 'closed';
+          this.emit('peer:disconnect', connection);
+          this.emit('connection:close', connection);
+        }
+      },
+    );
+  }
+
+  private setupProtocolHandlers(): void {
+    // Listen for protocol data events
+    this.eventEmitter.addListener(
+      'onProtocolData',
+      (data: { protocolId: string; peerId: string; data?: number[] }) => {
+        // Find matching protocol handler
+        const handler = this.options.protocols?.find((p) => p.protocolId === data.protocolId);
+        if (handler) {
+          // Convert number array to Uint8Array if needed
+          const uint8Data = data.data ? new Uint8Array(data.data) : undefined;
+          handler.handler({ peerId: data.peerId, data: uint8Data });
+        }
+      },
+    );
+  }
+
+  private emit<K extends keyof Libp2pEvents>(event: K, detail: unknown): void {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      const customEvent = new CustomEvent(event, { detail });
+      for (const handler of handlers) {
+        handler(customEvent as Libp2pEvents[K]);
+      }
+    }
+  }
+
+  async start(): Promise<void> {
+    // Register protocols if any
+    if (this.options.protocols && this.nativeModule.registerProtocolHandler) {
+      for (const protocol of this.options.protocols) {
+        await this.nativeModule.registerProtocolHandler(protocol.protocolId);
+      }
+    }
+
+    // Pass configuration options to native module including keypair
+    const config = {
+      tcpPort: this.options.config?.tcpPort,
+      wsPort: this.options.config?.wsPort,
+      // Convert Uint8Array to base64 for passing to native module
+      keypair: this.options.keypair
+        ? {
+            privateKey: btoa(String.fromCharCode(...this.options.keypair.privateKey)),
+            publicKey: btoa(String.fromCharCode(...this.options.keypair.publicKey)),
+          }
+        : undefined,
+    };
+
+    await this.nativeModule.startLibp2p(config);
+    this._started = true;
+  }
+
+  async stop(): Promise<void> {
+    try {
+      await this.nativeModule.stopLibp2p();
+      this._started = false;
+    } catch (error) {
+      // If libp2p wasn't running, that's okay - just update our state
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorCode = (error as { code?: string })?.code;
+      if (errorMessage.includes('not running') || errorCode === 'LIBP2P_ERROR') {
+        this._started = false;
+      } else {
+        // Re-throw other errors
+        throw error;
+      }
+    }
+  }
+
+  async dial(multiaddr: string): Promise<Connection> {
+    await this.nativeModule.connectToPeer(multiaddr);
+
+    // Create connection object
+    const peerId = multiaddr.match(/\/p2p\/([^/]+)/)?.[1] || '';
+    return {
+      id: `${peerId}-${Date.now()}`,
+      remotePeer: new SimplePeerId(peerId),
+      remoteAddr: new SimpleMultiaddr(multiaddr),
+      stat: {
+        direction: 'outbound',
+        status: 'open',
+        timeline: {
+          open: Date.now(),
+        },
+      },
+    };
+  }
+
+  async hangUp(peerId: string): Promise<void> {
+    const result = await this.nativeModule.hangUp(peerId);
+
+    if (!result?.success) {
+      // No active connections to peer - this is okay
+    }
+  }
+
+  async getConnections(peerId?: string): Promise<Connection[]> {
+    try {
+      const rawConnections = await this.nativeModule.getConnections();
+
+      // Transform native connections to match the Connection interface
+      this.cachedConnections = (rawConnections || []).map((conn: any) => {
+        // Ensure the connection has the expected structure
+        // Handle different formats from native modules
+        let peerIdStr = conn.peerId || 'unknown';
+        if (conn.remotePeer) {
+          // If remotePeer is an object with toString property (from native module)
+          if (typeof conn.remotePeer.toString === 'string') {
+            peerIdStr = conn.remotePeer.toString;
+          }
+          // If remotePeer is a PeerId object with toString method
+          else if (typeof conn.remotePeer.toString === 'function') {
+            peerIdStr = conn.remotePeer.toString();
+          }
+        }
+
+        const connection: Connection = {
+          id: conn.id || `${peerIdStr}-${Date.now()}`,
+          remotePeer: new SimplePeerId(peerIdStr),
+          remoteAddr: conn.remoteAddr?.toString
+            ? new SimpleMultiaddr(
+                typeof conn.remoteAddr.toString === 'string'
+                  ? conn.remoteAddr.toString
+                  : conn.remoteAddr.toString(),
+              )
+            : new SimpleMultiaddr('/unknown'),
+          stat: conn.stat || {
+            direction: conn.direction || 'outbound',
+            status: conn.status || 'open',
+            timeline: conn.timeline || {
+              open: Date.now(),
+            },
+          },
+        };
+        return connection;
+      });
+
+      // Filter by peerId if provided
+      if (peerId) {
+        return this.cachedConnections.filter((conn) => conn.remotePeer.toString() === peerId);
+      }
+
+      return this.cachedConnections;
+    } catch (_error) {
+      // Failed to get connections
+      return [];
+    }
+  }
+
+  addEventListener<K extends keyof Libp2pEvents>(
+    event: K,
+    handler: (evt: Libp2pEvents[K]) => void,
+  ): void {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, new Set());
+    }
+    this.eventHandlers.get(event)?.add(handler as EventHandler);
+  }
+
+  removeEventListener<K extends keyof Libp2pEvents>(
+    event: K,
+    handler: (evt: Libp2pEvents[K]) => void,
+  ): void {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler as EventHandler);
+    }
+  }
+
+  async refreshDiscovery(): Promise<void> {
+    if (this.nativeModule.refreshDiscovery) {
+      await this.nativeModule.refreshDiscovery();
+    }
+  }
+
+  async pingPeer(peerId: string): Promise<{ success: boolean; rtt?: number; peerId: string }> {
+    if (this.nativeModule.pingPeer) {
+      return await this.nativeModule.pingPeer(peerId);
+    } else {
+      throw new Error('Ping not supported on this platform');
+    }
+  }
+
+  async sendProtocolData(peerId: string, protocolId: string, data: Uint8Array): Promise<void> {
+    if (this.nativeModule.sendProtocolData) {
+      // Convert Uint8Array to regular array for native module
+      const dataArray = Array.from(data);
+      await this.nativeModule.sendProtocolData(peerId, protocolId, dataArray);
+    } else {
+      throw new Error('Protocol sending not supported on this platform');
+    }
+  }
+}
+
+// Type definition for CustomEventInit
+interface CustomEventInit<T = unknown> {
+  detail?: T;
+  bubbles?: boolean;
+  cancelable?: boolean;
+}
+
+// Polyfill CustomEvent for React Native
+if (typeof CustomEvent === 'undefined') {
+  const globalObj = global as typeof globalThis & { CustomEvent: typeof CustomEvent };
+  globalObj.CustomEvent = class CustomEvent<T = unknown> {
+    readonly type: string;
+    readonly detail: T;
+    readonly bubbles: boolean;
+    readonly cancelable: boolean;
+
+    constructor(type: string, eventInitDict?: CustomEventInit<T>) {
+      this.type = type;
+      this.detail = eventInitDict?.detail as T;
+      this.bubbles = eventInitDict?.bubbles || false;
+      this.cancelable = eventInitDict?.cancelable || false;
+    }
+
+    preventDefault() {}
+    stopPropagation() {}
+    stopImmediatePropagation() {}
+  } as any;
+}
\ No newline at end of file
diff --git a/implementations/SettingsService.ts b/implementations/SettingsService.ts
new file mode 100644
index 0000000..ff0a0c2
--- /dev/null
+++ b/implementations/SettingsService.ts
@@ -0,0 +1,298 @@
+/**
+ * Settings Service
+ *
+ * Manages application settings and provides methods to:
+ * - Load/save settings
+ * - Apply settings to native modules
+ * - Reset application data
+ */
+
+import { LoggerComponent } from 'ior:gitea:gitea.metatrom.net:universal-components/logger@1.0.0';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { NativeModules, Platform } from 'react-native';
+
+// Storage keys
+const SETTINGS_KEY = '@libp2p_settings';
+
+// Default settings
+export const DEFAULT_SETTINGS = {
+  tcpPort: 10000,
+  wsPort: 10005,
+  discoveryTimeout: 30000,
+  enableDebugLogs: false,
+  autoDiscovery: false,
+  useCustomPorts: false,
+  dhtServerUrl: 'ws://192.168.188.40:3000/ws', // This is the default/fallback DHT server URL
+};
+
+export interface AppSettings {
+  tcpPort: number;
+  wsPort: number;
+  discoveryTimeout: number;
+  enableDebugLogs: boolean;
+  autoDiscovery: boolean;
+  useCustomPorts: boolean;
+  dhtServerUrl: string;
+}
+
+export interface INativeModules {
+  Libp2pModule?: any;
+  DiscoveryModule?: any;
+  SecureStorageModule?: any;
+}
+
+export class SettingsService {
+  private static instance: SettingsService | null = null;
+  private currentSettings: AppSettings = DEFAULT_SETTINGS;
+  private logger = new LoggerComponent('SettingsService');
+  private nativeModules: INativeModules;
+
+  private constructor(nativeModules?: INativeModules) {
+    // Allow dependency injection of native modules
+    this.nativeModules = nativeModules || NativeModules;
+  }
+
+  public static getInstance(nativeModules?: INativeModules): SettingsService {
+    if (!SettingsService.instance) {
+      SettingsService.instance = new SettingsService(nativeModules);
+    }
+    return SettingsService.instance;
+  }
+
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  public static resetInstance(): void {
+    SettingsService.instance = null;
+  }
+
+  /**
+   * Initialize settings service
+   */
+  async initialize(): Promise<AppSettings> {
+    try {
+      const settings = await this.loadSettings();
+      this.currentSettings = settings;
+      return settings;
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to initialize:', error);
+      return DEFAULT_SETTINGS;
+    }
+  }
+
+  /**
+   * Load settings from storage
+   */
+  async loadSettings(): Promise<AppSettings> {
+    try {
+      const stored = await AsyncStorage.getItem(SETTINGS_KEY);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        return { ...DEFAULT_SETTINGS, ...parsed };
+      }
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to load settings:', error);
+    }
+    return DEFAULT_SETTINGS;
+  }
+
+  /**
+   * Save settings to storage
+   */
+  async saveSettings(settings: AppSettings): Promise<void> {
+    try {
+      await AsyncStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+      this.currentSettings = settings;
+
+      // Apply settings to native modules if needed
+      await this.applySettings(settings);
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to save settings:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Apply settings to native modules
+   */
+  private async applySettings(settings: AppSettings): Promise<void> {
+    const { Libp2pModule, DiscoveryModule } = this.nativeModules;
+
+    // Apply port settings if custom ports are enabled
+    if (settings.useCustomPorts) {
+      // This would need to be passed to the native modules
+      // when starting the libp2p node
+      this.logger.debug('[SettingsService] Custom ports:', {
+        tcp: settings.tcpPort,
+        ws: settings.wsPort,
+      });
+    }
+
+    // Apply debug logging
+    if (Libp2pModule?.setDebugConsoleOutput) {
+      Libp2pModule.setDebugConsoleOutput(settings.enableDebugLogs);
+    }
+
+    // Apply discovery timeout
+    if (DiscoveryModule?.setDiscoveryTimeout) {
+      DiscoveryModule.setDiscoveryTimeout(settings.discoveryTimeout);
+    }
+  }
+
+  /**
+   * Get current settings
+   */
+  getSettings(): AppSettings {
+    return this.currentSettings;
+  }
+
+  /**
+   * Get specific setting value
+   */
+  getSetting<K extends keyof AppSettings>(key: K): AppSettings[K] {
+    return this.currentSettings[key];
+  }
+
+  /**
+   * Update specific setting
+   */
+  async updateSetting<K extends keyof AppSettings>(key: K, value: AppSettings[K]): Promise<void> {
+    const newSettings = { ...this.currentSettings, [key]: value };
+    await this.saveSettings(newSettings);
+  }
+
+  /**
+   * Reset all application data
+   */
+  async resetAllData(): Promise<void> {
+    try {
+      this.logger.info('[SettingsService] Starting app reset...');
+
+      // Clear all AsyncStorage (this includes dht_discovered_users)
+      const allKeys = await AsyncStorage.getAllKeys();
+      this.logger.debug('[SettingsService] Clearing AsyncStorage keys:', allKeys);
+      await AsyncStorage.multiRemove(allKeys);
+
+      // Clear native module data
+      await this.clearNativeData();
+
+      // Reset settings to defaults
+      this.currentSettings = DEFAULT_SETTINGS;
+
+      this.logger.info('[SettingsService] App reset complete');
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to reset app data:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Clear native module stored data
+   */
+  private async clearNativeData(): Promise<void> {
+    const { Libp2pModule, DiscoveryModule, SecureStorageModule } = this.nativeModules;
+
+    try {
+      if (Platform.OS === 'ios') {
+        // Clear iOS UserDefaults
+        if (Libp2pModule?.clearStoredData) {
+          await Libp2pModule.clearStoredData();
+        }
+        if (DiscoveryModule?.clearStoredData) {
+          await DiscoveryModule.clearStoredData();
+        }
+        if (SecureStorageModule?.clearAll) {
+          await SecureStorageModule.clearAll();
+        }
+      } else if (Platform.OS === 'android') {
+        // Clear Android SharedPreferences
+        if (Libp2pModule?.clearStoredData) {
+          await Libp2pModule.clearStoredData();
+        }
+        if (DiscoveryModule?.clearStoredData) {
+          await DiscoveryModule.clearStoredData();
+        }
+        if (SecureStorageModule?.clearAll) {
+          await SecureStorageModule.clearAll();
+        }
+      }
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to clear native data:', error);
+      // Continue even if native clear fails
+    }
+  }
+
+  /**
+   * Export all app data for debugging
+   */
+  async exportDebugData(): Promise<object> {
+    try {
+      const allKeys = await AsyncStorage.getAllKeys();
+      const allData: Record<string, unknown> = {};
+
+      for (const key of allKeys) {
+        try {
+          const value = await AsyncStorage.getItem(key);
+          allData[key] = value ? JSON.parse(value) : null;
+        } catch {
+          // If JSON parse fails, store as string
+          allData[key] = await AsyncStorage.getItem(key);
+        }
+      }
+
+      return {
+        settings: this.currentSettings,
+        storedData: allData,
+        platform: Platform.OS,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to export debug data:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if this is first app launch
+   */
+  async isFirstLaunch(): Promise<boolean> {
+    try {
+      const hasSettings = await AsyncStorage.getItem(SETTINGS_KEY);
+      return !hasSettings;
+    } catch {
+      return true;
+    }
+  }
+
+  /**
+   * Get storage info
+   */
+  async getStorageInfo(): Promise<{
+    keys: string[];
+    totalSize: number;
+  }> {
+    try {
+      const allKeys = await AsyncStorage.getAllKeys();
+      let totalSize = 0;
+
+      for (const key of allKeys) {
+        const value = await AsyncStorage.getItem(key);
+        if (value) {
+          totalSize += value.length;
+        }
+      }
+
+      return {
+        keys: [...allKeys], // Convert readonly array to mutable array
+        totalSize,
+      };
+    } catch (error) {
+      this.logger.error('[SettingsService] Failed to get storage info:', error);
+      return { keys: [], totalSize: 0 };
+    }
+  }
+}
+
+// Export singleton getter function instead of instance
+export const getSettingsService = (nativeModules?: INativeModules) => 
+  SettingsService.getInstance(nativeModules);
\ No newline at end of file
diff --git a/implementations/SettingsUI.tsx b/implementations/SettingsUI.tsx
new file mode 100644
index 0000000..bb47170
--- /dev/null
+++ b/implementations/SettingsUI.tsx
@@ -0,0 +1,496 @@
+/**
+ * Settings UI Component
+ *
+ * Provides configuration options for the libp2p node including:
+ * - Port configuration
+ * - Network settings
+ * - Data management (reset app)
+ * - Debug options
+ */
+
+import { LoggerComponent } from 'ior:gitea:gitea.metatrom.net:universal-components/logger@1.0.0';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import {
+  Alert,
+  KeyboardAvoidingView,
+  NativeModules,
+  Platform,
+  ScrollView,
+  StyleSheet,
+  Switch,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  View,
+} from 'react-native';
+// SecureStorage removed - not needed in external package
+import { DEFAULT_SETTINGS, type AppSettings } from './SettingsService';
+
+const { Libp2pModule, DiscoveryModule, SecureStorageModule } = NativeModules;
+
+// Settings storage keys
+const SETTINGS_STORAGE_KEY = '@libp2p_settings';
+
+// Use AppSettings from SettingsService
+// The LibP2PSettings type is now replaced by AppSettings
+
+interface SettingsUIProps {
+  initialSettings?: AppSettings;
+  onSettingsChange?: (settings: AppSettings) => void;
+  onPortsSaved?: () => void;
+  onReset?: () => void;
+}
+
+export const SettingsUI: React.FC<SettingsUIProps> = ({
+  initialSettings,
+  onSettingsChange,
+  onPortsSaved,
+  onReset,
+}) => {
+  const loggerRef = useRef<LoggerComponent | null>(null);
+  if (!loggerRef.current) {
+    loggerRef.current = new LoggerComponent('SettingsUI');
+  }
+  const logger = loggerRef.current;
+  const [settings, setSettings] = useState<AppSettings>(initialSettings || DEFAULT_SETTINGS);
+  const [isDirty, setIsDirty] = useState(false);
+  const [tcpPortInput, setTcpPortInput] = useState(
+    String((initialSettings || DEFAULT_SETTINGS).tcpPort),
+  );
+  const [wsPortInput, setWsPortInput] = useState(
+    String((initialSettings || DEFAULT_SETTINGS).wsPort),
+  );
+  const [discoveryTimeoutInput, setDiscoveryTimeoutInput] = useState(
+    String((initialSettings || DEFAULT_SETTINGS).discoveryTimeout / 1000),
+  );
+  const [dhtServerUrlInput, setDhtServerUrlInput] = useState(
+    (initialSettings || DEFAULT_SETTINGS).dhtServerUrl,
+  );
+
+  // Update state when initialSettings changes
+  useEffect(() => {
+    if (initialSettings) {
+      setSettings(initialSettings);
+      setTcpPortInput(String(initialSettings.tcpPort));
+      setWsPortInput(String(initialSettings.wsPort));
+      setDiscoveryTimeoutInput(String(initialSettings.discoveryTimeout / 1000));
+      setDhtServerUrlInput(initialSettings.dhtServerUrl);
+    } else {
+      loadSettings();
+    }
+  }, [initialSettings]);
+
+  /**
+   * Load settings from AsyncStorage
+   */
+  const loadSettings = async () => {
+    try {
+      const stored = await AsyncStorage.getItem(SETTINGS_STORAGE_KEY);
+      let loadedSettings: LibP2PSettings;
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        loadedSettings = { ...DEFAULT_SETTINGS, ...parsed };
+      } else {
+        // No stored settings, use defaults
+        loadedSettings = DEFAULT_SETTINGS;
+      }
+
+      setSettings(loadedSettings);
+      setTcpPortInput(String(loadedSettings.tcpPort));
+      setWsPortInput(String(loadedSettings.wsPort));
+      setDiscoveryTimeoutInput(String(loadedSettings.discoveryTimeout / 1000));
+      setDhtServerUrlInput(loadedSettings.dhtServerUrl);
+
+      // Don't call onSettingsChange during initial load
+      // Parent component should handle initial settings
+    } catch (error) {
+      logger.error('[Settings] Failed to load settings:', error);
+      // On error, still load defaults
+      setSettings(DEFAULT_SETTINGS);
+      setTcpPortInput(String(DEFAULT_SETTINGS.tcpPort));
+      setWsPortInput(String(DEFAULT_SETTINGS.wsPort));
+      setDiscoveryTimeoutInput(String(DEFAULT_SETTINGS.discoveryTimeout / 1000));
+      setDhtServerUrlInput(DEFAULT_SETTINGS.dhtServerUrl);
+    }
+  };
+
+  /**
+   * Save settings to AsyncStorage
+   */
+  const saveSettings = async () => {
+    try {
+      // Validate ports
+      const tcpPort = Number.parseInt(tcpPortInput, 10);
+      const wsPort = Number.parseInt(wsPortInput, 10);
+      const discoveryTimeout = Number.parseInt(discoveryTimeoutInput, 10) * 1000;
+
+      if (Number.isNaN(tcpPort) || tcpPort < 1024 || tcpPort > 65535) {
+        Alert.alert('Invalid TCP Port', 'Please enter a valid port number (1024-65535)');
+        return;
+      }
+
+      if (Number.isNaN(wsPort) || wsPort < 1024 || wsPort > 65535) {
+        Alert.alert('Invalid WebSocket Port', 'Please enter a valid port number (1024-65535)');
+        return;
+      }
+
+      if (Number.isNaN(discoveryTimeout) || discoveryTimeout < 5000 || discoveryTimeout > 300000) {
+        Alert.alert('Invalid Discovery Timeout', 'Please enter a value between 5 and 300 seconds');
+        return;
+      }
+
+      const newSettings = {
+        ...settings,
+        tcpPort,
+        wsPort,
+        discoveryTimeout,
+        dhtServerUrl: dhtServerUrlInput,
+      };
+
+      await AsyncStorage.setItem(SETTINGS_STORAGE_KEY, JSON.stringify(newSettings));
+      setSettings(newSettings);
+      setIsDirty(false);
+
+      if (onSettingsChange) {
+        onSettingsChange(newSettings);
+      }
+
+      // Call the onPortsSaved callback to trigger libp2p restart
+      if (onPortsSaved) {
+        onPortsSaved();
+      }
+    } catch (error) {
+      logger.error('[Settings] Failed to save settings:', error);
+      Alert.alert('Error', 'Failed to save settings');
+    }
+  };
+
+  /**
+   * Reset all app data
+   */
+  const resetApp = () => {
+    Alert.alert(
+      'Reset App Data',
+      'This will delete all stored data including:\n\n• Your peer identity\n• All settings\n• Stored devices\n• Chat history\n\nThe app will be like freshly installed. Continue?',
+      [
+        { text: 'Cancel', style: 'cancel' },
+        {
+          text: 'Reset',
+          style: 'destructive',
+          onPress: async () => {
+            try {
+              // Show progress alert
+              Alert.alert('Resetting...', 'Please wait while we clear all data');
+
+              // Clear all AsyncStorage
+              await AsyncStorage.clear();
+
+              // Clear all secure storage (identities, paired devices, etc.)
+              try {
+                // Clear secure storage if available
+                if (SecureStorageModule?.clearAll) {
+                  await SecureStorageModule.clearAll();
+                }
+                logger.info('[SettingsUI] Cleared all secure storage data');
+              } catch (error) {
+                logger.error('[SettingsUI] Failed to clear secure storage:', error);
+              }
+
+              // Clear native module stored data
+              if (Platform.OS === 'ios') {
+                // iOS uses UserDefaults
+                if (Libp2pModule.clearStoredData) {
+                  await Libp2pModule.clearStoredData();
+                }
+                if (DiscoveryModule.clearStoredData) {
+                  await DiscoveryModule.clearStoredData();
+                }
+                // SecureStorage handled above
+              } else if (Platform.OS === 'android') {
+                // Android uses SharedPreferences
+                if (Libp2pModule.clearStoredData) {
+                  await Libp2pModule.clearStoredData();
+                }
+                if (DiscoveryModule.clearStoredData) {
+                  await DiscoveryModule.clearStoredData();
+                }
+                if (SecureStorageModule?.clearAll) {
+                  await SecureStorageModule.clearAll();
+                }
+              }
+
+              // Reset settings to defaults
+              setSettings(DEFAULT_SETTINGS);
+              setTcpPortInput(String(DEFAULT_SETTINGS.tcpPort));
+              setWsPortInput(String(DEFAULT_SETTINGS.wsPort));
+              setDiscoveryTimeoutInput(String(DEFAULT_SETTINGS.discoveryTimeout / 1000));
+              setDhtServerUrlInput(DEFAULT_SETTINGS.dhtServerUrl);
+
+              if (onReset) {
+                onReset();
+              }
+
+              Alert.alert(
+                'Reset Complete',
+                'All app data has been cleared. Please restart the app for a fresh start.',
+                [
+                  {
+                    text: 'OK',
+                    onPress: () => {
+                      // Optionally restart the app
+                      // RNRestart.Restart(); // Requires react-native-restart package
+                    },
+                  },
+                ],
+              );
+            } catch (error) {
+              logger.error('[Settings] Failed to reset app:', error);
+              Alert.alert('Error', 'Failed to reset app data');
+            }
+          },
+        },
+      ],
+    );
+  };
+
+  const handleToggleCustomPorts = async () => {
+    const newSettings = { ...settings, useCustomPorts: !settings.useCustomPorts };
+    setSettings(newSettings);
+
+    // Auto-save switch changes immediately
+    try {
+      await AsyncStorage.setItem(SETTINGS_STORAGE_KEY, JSON.stringify(newSettings));
+      if (onSettingsChange) {
+        onSettingsChange(newSettings);
+      }
+    } catch (error) {
+      logger.error('[Settings] Failed to save setting:', error);
+    }
+  };
+
+  return (
+    <KeyboardAvoidingView
+      style={styles.container}
+      behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
+      keyboardVerticalOffset={Platform.OS === 'ios' ? 0 : 0}
+    >
+      <ScrollView
+        style={styles.scrollView}
+        contentContainerStyle={styles.scrollContent}
+        showsVerticalScrollIndicator={true}
+        keyboardShouldPersistTaps="handled"
+      >
+        <View style={styles.section}>
+          <Text style={styles.sectionTitle}>Network Configuration</Text>
+
+          <View style={styles.setting}>
+            <Text style={styles.settingLabel}>Use Custom Ports</Text>
+            <Switch
+              value={settings.useCustomPorts}
+              onValueChange={handleToggleCustomPorts}
+              trackColor={{ false: '#767577', true: '#2196F3' }}
+              thumbColor={settings.useCustomPorts ? '#fff' : '#f4f3f4'}
+              ios_backgroundColor="#3e3e3e"
+            />
+          </View>
+
+          {settings.useCustomPorts && (
+            <>
+              <View style={styles.inputSetting}>
+                <Text style={styles.settingLabel}>TCP Port</Text>
+                <TextInput
+                  style={styles.input}
+                  value={tcpPortInput}
+                  onChangeText={(text) => {
+                    setTcpPortInput(text);
+                    setIsDirty(true);
+                  }}
+                  keyboardType="number-pad"
+                  placeholder="10000"
+                  placeholderTextColor="#666"
+                  maxLength={5}
+                />
+              </View>
+
+              <View style={styles.inputSetting}>
+                <Text style={styles.settingLabel}>WebSocket Port</Text>
+                <TextInput
+                  style={styles.input}
+                  value={wsPortInput}
+                  onChangeText={(text) => {
+                    setWsPortInput(text);
+                    setIsDirty(true);
+                  }}
+                  keyboardType="number-pad"
+                  placeholder="10005"
+                  placeholderTextColor="#666"
+                  maxLength={5}
+                />
+              </View>
+            </>
+          )}
+        </View>
+
+        <View style={styles.section}>
+          <Text style={styles.sectionTitle}>Discovery Configuration</Text>
+
+          <View style={styles.inputSetting}>
+            <Text style={styles.settingLabel}>Timeout (seconds)</Text>
+            <TextInput
+              style={styles.input}
+              value={discoveryTimeoutInput}
+              onChangeText={(text) => {
+                setDiscoveryTimeoutInput(text);
+                setIsDirty(true);
+              }}
+              keyboardType="number-pad"
+              placeholder="30"
+              placeholderTextColor="#666"
+              maxLength={3}
+            />
+          </View>
+
+          <View style={styles.inputSetting}>
+            <Text style={styles.settingLabel}>DHT Server URL</Text>
+            <TextInput
+              style={styles.input}
+              value={dhtServerUrlInput}
+              onChangeText={(text) => {
+                setDhtServerUrlInput(text);
+                setIsDirty(true);
+              }}
+              placeholder="ws://192.168.188.40:3000/ws"
+              placeholderTextColor="#666"
+              selectionColor="#2196F3"
+              autoCapitalize="none"
+              autoCorrect={false}
+              underlineColorAndroid="transparent"
+            />
+            <Text style={styles.settingDescription}>
+              WebSocket URL of the DHT server for global peer discovery
+            </Text>
+          </View>
+        </View>
+
+        {isDirty && (
+          <View style={styles.section}>
+            <TouchableOpacity style={styles.saveButton} onPress={saveSettings}>
+              <Text style={styles.saveButtonText}>Save Settings</Text>
+            </TouchableOpacity>
+          </View>
+        )}
+
+        <View style={[styles.section, styles.lastSection]}>
+          <TouchableOpacity style={styles.dangerButton} onPress={resetApp}>
+            <Text style={styles.dangerButtonText}>🗑 Reset All App Data</Text>
+          </TouchableOpacity>
+
+          <Text style={styles.warningText}>
+            This will delete all stored data and reset the app to its initial state
+          </Text>
+        </View>
+      </ScrollView>
+    </KeyboardAvoidingView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: 'transparent',
+  },
+  scrollView: {
+    flex: 1,
+  },
+  scrollContent: {
+    paddingVertical: 20,
+    paddingBottom: 100, // Increased to ensure all content is visible
+  },
+  section: {
+    paddingHorizontal: 20,
+    marginBottom: 24,
+  },
+  sectionTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#fff',
+    marginBottom: 16,
+  },
+  setting: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'flex-start',
+    paddingVertical: 16,
+  },
+  settingInfo: {
+    flex: 1,
+    marginRight: 12,
+  },
+  settingLabel: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#fff',
+    marginBottom: 4,
+  },
+  settingDescription: {
+    fontSize: 12,
+    color: '#999',
+    marginTop: 2,
+  },
+  inputSetting: {
+    paddingVertical: 12,
+  },
+  input: {
+    marginTop: 8,
+    paddingHorizontal: 12,
+    paddingVertical: Platform.OS === 'ios' ? 10 : 8,
+    backgroundColor: '#2a2a2a',
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: '#333',
+    fontSize: 14,
+    color: '#fff',
+    textAlignVertical: 'center',
+    minHeight: Platform.OS === 'android' ? 40 : undefined,
+  },
+  dangerButton: {
+    marginTop: 12,
+    paddingVertical: 12,
+    paddingHorizontal: 20,
+    backgroundColor: '#5c1e1e',
+    borderRadius: 8,
+    alignItems: 'center',
+  },
+  dangerButtonText: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#ff9999',
+  },
+  saveButton: {
+    marginTop: 16,
+    paddingVertical: 12,
+    paddingHorizontal: 20,
+    backgroundColor: '#2563eb',
+    borderRadius: 8,
+    alignItems: 'center',
+  },
+  saveButtonText: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#fff',
+  },
+  warningText: {
+    fontSize: 12,
+    color: '#999',
+    textAlign: 'center',
+    marginTop: 8,
+    fontStyle: 'italic',
+  },
+  lastSection: {
+    marginBottom: 40,
+  },
+});
+
+export default SettingsUI;
diff --git a/index.ts b/index.ts
new file mode 100644
index 0000000..b4577c1
--- /dev/null
+++ b/index.ts
@@ -0,0 +1,42 @@
+/**
+ * @metatrom/libp2p-native-bridge
+ * 
+ * Native libp2p bridge for React Native applications
+ * Provides a unified interface for iOS and Android libp2p implementations
+ */
+
+// Main component export
+export { Libp2pComponent, SimplePeerId, SimpleMultiaddr } from './implementations/Libp2pComponent';
+
+// Settings exports
+export { 
+  SettingsService, 
+  getSettingsService,
+  DEFAULT_SETTINGS,
+  type AppSettings,
+  type INativeModules 
+} from './implementations/SettingsService';
+
+// UI Components
+export { SettingsUI } from './implementations/SettingsUI';
+
+// Interface exports
+export * from './interfaces/ILibp2pComponent';
+export * from './interfaces/types';
+
+// Utility exports
+export * from './utils/constants';
+export * from './utils/eventHelpers';
+export * from './utils/types';
+
+// Re-export commonly used types for convenience
+export type {
+  Connection,
+  ILibp2pComponent,
+  Libp2pEvents,
+  Libp2pOptions,
+  Multiaddr,
+  PeerId,
+  PeerInfo,
+  ProtocolHandler,
+} from './interfaces/ILibp2pComponent';
\ No newline at end of file
diff --git a/interfaces/ILibp2pComponent.ts b/interfaces/ILibp2pComponent.ts
new file mode 100644
index 0000000..96cdf60
--- /dev/null
+++ b/interfaces/ILibp2pComponent.ts
@@ -0,0 +1,87 @@
+/**
+ * Core libp2p component interfaces
+ */
+
+export interface PeerId {
+  toString(): string;
+  toBytes(): Uint8Array;
+  equals(other: PeerId): boolean;
+}
+
+export interface Multiaddr {
+  toString(): string;
+  bytes: Uint8Array;
+  protos(): Array<{ code: number; name: string }>;
+  getPeerId(): string | null;
+}
+
+export interface Connection {
+  id: string;
+  remotePeer: PeerId;
+  remoteAddr: Multiaddr;
+  stat: {
+    direction: 'inbound' | 'outbound';
+    status: 'pending' | 'open' | 'closing' | 'closed';
+    timeline: {
+      open: number;
+      upgraded?: number;
+      close?: number;
+    };
+  };
+}
+
+export interface PeerInfo {
+  id: PeerId;
+  multiaddrs: Multiaddr[];
+}
+
+export interface ProtocolHandler {
+  protocolId: string;
+  handler: (data: { peerId: string; data?: Uint8Array }) => void | Promise<void>;
+}
+
+export interface ILibp2pComponent {
+  peerId: PeerId | null;
+  multiaddrs: Multiaddr[];
+
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  dial(multiaddr: string): Promise<Connection>;
+  hangUp(peerId: string): Promise<void>;
+  getConnections(peerId?: string): Promise<Connection[]>;
+  sendProtocolData(peerId: string, protocolId: string, data: Uint8Array): Promise<void>;
+  refreshDiscovery(): Promise<void>;
+  pingPeer(peerId: string): Promise<{ success: boolean; rtt?: number; peerId: string }>;
+
+  addEventListener<K extends keyof Libp2pEvents>(
+    event: K,
+    handler: (evt: Libp2pEvents[K]) => void,
+  ): void;
+
+  removeEventListener<K extends keyof Libp2pEvents>(
+    event: K,
+    handler: (evt: Libp2pEvents[K]) => void,
+  ): void;
+}
+
+export interface Libp2pEvents {
+  'peer:discovery': CustomEvent<PeerInfo>;
+  'peer:lost': CustomEvent<{ id: PeerId }>;
+  'peer:connect': CustomEvent<Connection>;
+  'peer:disconnect': CustomEvent<Connection>;
+  'connection:open': CustomEvent<Connection>;
+  'connection:close': CustomEvent<Connection>;
+  'self:peer:update': CustomEvent<{ peerId: PeerId; multiaddrs: Multiaddr[] }>;
+}
+
+export interface Libp2pOptions {
+  config?: {
+    tcpPort?: number;
+    wsPort?: number;
+  };
+  protocols?: ProtocolHandler[];
+  keypair?: {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+  };
+}
\ No newline at end of file
diff --git a/interfaces/index.ts b/interfaces/index.ts
new file mode 100644
index 0000000..8d8bdb3
--- /dev/null
+++ b/interfaces/index.ts
@@ -0,0 +1,6 @@
+/**
+ * Export all interfaces
+ */
+
+export * from './ILibp2pComponent';
+export * from './types';
\ No newline at end of file
diff --git a/interfaces/types.ts b/interfaces/types.ts
new file mode 100644
index 0000000..c7d7277
--- /dev/null
+++ b/interfaces/types.ts
@@ -0,0 +1,20 @@
+/**
+ * Type definitions for libp2p native bridge
+ */
+
+export type { 
+  ConnectionStatusEvent, 
+  PeerDiscoveredEvent, 
+  PeerInfoEvent 
+} from '../utils/types';
+
+// Re-export common types from ILibp2pComponent for convenience
+export type {
+  PeerId,
+  Multiaddr,
+  Connection,
+  PeerInfo,
+  ProtocolHandler,
+  Libp2pEvents,
+  Libp2pOptions
+} from './ILibp2pComponent';
\ No newline at end of file
diff --git a/native/libp2p.d.ts b/native/libp2p.d.ts
new file mode 100644
index 0000000..d85a2f9
--- /dev/null
+++ b/native/libp2p.d.ts
@@ -0,0 +1 @@
+// This file is no longer needed as types have been moved to libp2p.ts
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a1702bf
--- /dev/null
+++ b/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "@metatrom/libp2p-native-bridge",
+  "version": "1.0.0",
+  "main": "index.ts",
+  "type": "module",
+  "description": "Native libp2p bridge for React Native applications",
+  "metatrom": {
+    "ior": "com.metatrom.libp2p-native-bridge@1.0.0",
+    "capabilities": {
+      "p2p": true,
+      "contracts": false,
+      "viewer": false,
+      "sync": true
+    }
+  },
+  "exports": {
+    ".": "./index.ts",
+    "./settings": "./implementations/SettingsService.ts",
+    "./ui": "./implementations/SettingsUI.tsx",
+    "./interfaces": "./interfaces/index.ts"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0",
+    "@react-native-async-storage/async-storage": "*"
+  },
+  "keywords": [
+    "libp2p",
+    "react-native",
+    "p2p",
+    "networking",
+    "metatrom"
+  ],
+  "author": "Metatrom",
+  "license": "MIT"
+}
\ No newline at end of file
diff --git a/utils/constants.ts b/utils/constants.ts
new file mode 100644
index 0000000..712ce66
--- /dev/null
+++ b/utils/constants.ts
@@ -0,0 +1,45 @@
+/**
+ * Shared constants for libp2p configuration across platforms
+ */
+
+export const LIBP2P_CONFIG = {
+  // Default ports
+  DEFAULT_TCP_PORT: 10000,
+  DEFAULT_WS_PORT: 10001,
+
+  // Connection timeouts (in milliseconds)
+  CONNECTION_PENDING_TIMEOUT: 30000, // 30 seconds before removing pending connections
+  CONNECTION_FAILED_VISIBILITY: 5000, // 5 seconds to keep failed connections visible
+  CONNECTION_ACCEPTANCE_CHECK_DELAY: 5000, // 5 seconds before checking acceptance
+
+  // Monitoring intervals (in milliseconds)
+  CONNECTION_MONITOR_INTERVAL: 3000, // Check connections every 3 seconds
+  CONNECTION_SYNC_INTERVAL: 5000, // Sync connections every 5 seconds
+
+  // Protocol IDs
+  PROTOCOLS: {
+    CONNECTION_ACCEPT: '/metatrom/connection-accept/1.0.0',
+    CONNECTION_ACCEPTED: '/metatrom/connection-accepted/1.0.0',
+  },
+
+  // Connection states
+  CONNECTION_STATUS: {
+    PENDING: 'pending',
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    FAILED: 'failed',
+    CLOSING: 'closing',
+    CLOSED: 'closed',
+  } as const,
+
+  // Connection directions
+  CONNECTION_DIRECTION: {
+    INBOUND: 'inbound',
+    OUTBOUND: 'outbound',
+  } as const,
+} as const;
+
+export type ConnectionStatus =
+  (typeof LIBP2P_CONFIG.CONNECTION_STATUS)[keyof typeof LIBP2P_CONFIG.CONNECTION_STATUS];
+export type ConnectionDirection =
+  (typeof LIBP2P_CONFIG.CONNECTION_DIRECTION)[keyof typeof LIBP2P_CONFIG.CONNECTION_DIRECTION];
diff --git a/utils/eventHelpers.ts b/utils/eventHelpers.ts
new file mode 100644
index 0000000..cf2e607
--- /dev/null
+++ b/utils/eventHelpers.ts
@@ -0,0 +1,103 @@
+/**
+ * Helper functions for standardized event emission across platforms
+ * Import this file in native modules to ensure consistent event structures
+ */
+
+import type {
+  ConnectionStatusEvent,
+  ErrorEvent,
+  LogEvent,
+  PeerDiscoveredEvent,
+  PeerInfoEvent,
+  PeerLostEvent,
+} from './types';
+
+/**
+ * Creates a standardized connection status event payload
+ */
+export function createConnectionStatusEvent(
+  peerId: string,
+  status: string,
+  direction?: string,
+  multiaddr?: string,
+  error?: string,
+  reason?: string,
+): ConnectionStatusEvent {
+  return {
+    peerId,
+    status: status as ConnectionStatus,
+    direction: direction as ConnectionDirection,
+    multiaddr,
+    error,
+    reason,
+  };
+}
+
+/**
+ * Creates a standardized peer discovered event payload
+ */
+export function createPeerDiscoveredEvent(
+  peerId: string,
+  addresses: string[],
+): PeerDiscoveredEvent {
+  return {
+    peerId,
+    addresses,
+    multiaddrs: addresses, // Use same array for both for compatibility
+  };
+}
+
+/**
+ * Creates a standardized peer lost event payload
+ */
+export function createPeerLostEvent(peerId: string): PeerLostEvent {
+  return {
+    peerId,
+  };
+}
+
+/**
+ * Creates a standardized log event payload
+ */
+export function createLogEvent(
+  message: string,
+  level: 'debug' | 'info' | 'warn' | 'error' = 'info',
+): LogEvent {
+  return {
+    message,
+    level,
+  };
+}
+
+/**
+ * Creates a standardized error event payload
+ */
+export function createErrorEvent(message: string, code?: string): ErrorEvent {
+  return {
+    message,
+    code,
+  };
+}
+
+/**
+ * Creates a standardized peer info event payload
+ */
+export function createPeerInfoEvent(peerId: string, multiaddrs: string[]): PeerInfoEvent {
+  return {
+    peerId,
+    multiaddrs,
+  };
+}
+
+/**
+ * Event names used across platforms
+ */
+export const EVENT_NAMES = {
+  PEER_INFO: 'onPeerInfo',
+  PEER_DISCOVERED: 'onPeerDiscovered',
+  PEER_LOST: 'onPeerLost',
+  CONNECTION_STATUS: 'onConnectionStatus',
+  INCOMING_CONNECTION: 'onIncomingConnection',
+  LOG: 'onLog',
+  ERROR: 'onError',
+} as const;
diff --git a/utils/types.ts b/utils/types.ts
new file mode 100644
index 0000000..2f0d241
--- /dev/null
+++ b/utils/types.ts
@@ -0,0 +1,54 @@
+/**
+ * Shared types for libp2p implementation across platforms
+ */
+
+import type { ConnectionDirection, ConnectionStatus } from './constants';
+
+/**
+ * Unified connection information structure used by both iOS and Android
+ */
+export interface ConnectionInfo {
+  peerId: string;
+  status: ConnectionStatus;
+  direction: ConnectionDirection;
+  multiaddr?: string;
+  timestamp: number; // Unix timestamp in seconds
+  error?: string;
+}
+
+/**
+ * Event payloads for consistent event handling across platforms
+ */
+export interface ConnectionStatusEvent {
+  peerId: string;
+  status: ConnectionStatus;
+  direction?: ConnectionDirection;
+  multiaddr?: string;
+  error?: string;
+  reason?: string;
+}
+
+export interface PeerDiscoveredEvent {
+  peerId: string;
+  addresses?: string[];
+  multiaddrs?: string[];
+}
+
+export interface PeerLostEvent {
+  peerId: string;
+}
+
+export interface LogEvent {
+  message: string;
+  level?: 'debug' | 'info' | 'warn' | 'error';
+}
+
+export interface ErrorEvent {
+  message: string;
+  code?: string;
+}
+
+export interface PeerInfoEvent {
+  peerId: string;
+  multiaddrs: string[];
+}