Edge Networking & Mobile Strategy

Bringing Amigos to the edge with Weshnet integration and mobile-first design.

Vision: Computing Everywhere

Core Principle: Amigos services should run anywhere - from data centers to smartphones to offline mesh networks.

Weshnet Integration (Long-term)

What Weshnet Brings

Offline-First: Services work without internet
Mesh Networking: Direct device-to-device communication
Privacy Layer: Anonymous routing when needed
Resilience: Censorship-resistant by design

Integration Architecture

┌─────────────────┐     ┌─────────────────┐
│  Amigos Cloud   │     │  Amigos Edge    │
│  (Cosmos PoS)   │────▶│   (Weshnet)     │
└─────────────────┘     └─────────────────┘
         │                       │
         ▼                       ▼
   [Data Centers]         [Mobile Devices]
   [High Stakes]          [Local First]
   [Global State]         [Personal Data]

Use Cases

1. Offline Service Sync

// In the city with connection
wallet := amigos.Import("hub.amigos.dev/wallet")
wallet.Sync() // Download latest state

// In remote area without internet
payment := wallet.Pay(recipient, amount)
// Transaction stored locally via Weshnet

// Back in connectivity
wallet.Sync() // Uploads pending transactions

2. Local Mesh Networks

Disaster zones where internet is down
Conference/event local services
Community networks in remote areas
Protests/situations needing privacy

3. Edge Computing

Run Amigos services on phones
Local-first with cloud sync
Reduced latency for users
Data sovereignty maintained

Timeline

Phase 1 (Year 2-3): Research integration points
Phase 2 (Year 3-4): Prototype edge nodes
Phase 3 (Year 4-5): Production rollout

Mobile Wallet (Early Priority)

Why Mobile First?

Accessibility: Everyone has a phone
Identity: Phone = personal identity device
Payments: Mobile payments dominate globally
Developer Gateway: Easy first app to build

MVP Features (Q2 2026)

Core Functionality

Import Management: Browse and use imports
Account Sessions: Secure multi-device access
Token Wallet: Send/receive/stake tokens
Service Browser: Discover and interact with services

Technical Requirements

React Native for cross-platform
Hardware wallet support (iOS Secure Enclave, Android Keystore)
Biometric authentication
QR code scanning for payments
Push notifications for transactions

Account Sessions System

The Problem

Traditional wallets have a single private key - lose it and lose everything. We need better UX without sacrificing security.

The Solution: Sessions

// Master account creates sessions
account := amigos.Account(masterKey)
mobileSession := account.CreateSession(
    Device("iPhone 14 Pro"),
    Permissions(SEND_LIMIT_DAILY, READ_ALL),
    Expiry(30 * 24 * time.Hour),
)

// Mobile device uses session
session := amigos.Session(sessionKey)
session.Send(recipient, amount) // Works up to daily limit
session.Send(recipient, hugeAmount) // Fails - exceeds permission

Session Features

Device Management
- Name devices for easy identification
- Revoke compromised devices instantly
- See all active sessions
- Geographic restrictions optional

Permission Levels

const (
    READ_ONLY           // View balances, history
    SEND_LIMIT_DAILY    // Send up to X per day
    SEND_LIMIT_TX       // Send up to X per transaction  
    SEND_UNLIMITED      // Full sending rights
    STAKE_MANAGE        // Can stake/unstake
    IMPORT_EXECUTE      // Can run imported services
    ACCOUNT_RECOVER     // Can add recovery methods
)

Recovery Mechanisms
- Social recovery (M of N friends)
- Time-locked recovery
- Hardware key backup
- Session upgrade paths
Security Features
- Sessions can’t create sessions (no recursion)
- Automatic expiry
- Transaction limits
- Notification on new sessions
- Kill switch for all sessions

Mobile Wallet Architecture

┌─────────────────────────┐
│     Mobile Wallet       │
├─────────────────────────┤
│   Session Manager       │ ← Handles multiple sessions
├─────────────────────────┤
│   Import Browser        │ ← Discover/use services  
├─────────────────────────┤
│   Transaction Engine    │ ← Send/receive/sign
├─────────────────────────┤
│   Secure Storage        │ ← iOS/Android secure enclave
├─────────────────────────┤
│   Weshnet (Future)      │ ← Offline capabilities
└─────────────────────────┘

User Journey

First Time Setup

Download Amigos Wallet
Create master account or import existing
Biometric authentication setup
Automatic session creation for device
Ready to use in < 60 seconds

Daily Usage

Open with FaceID/Fingerprint
See balance and recent activity
Scan QR to pay or receive
Browse and use imported services
Get notifications for important events

Multi-Device Setup

On new device: “Add Device”
On old device: Approve via notification
Set permissions for new device
Optionally set expiry
Start using immediately

Implementation Priorities

Q1 2026: Foundation

[ ] Session system in core protocol
[ ] Basic permission framework
[ ] Recovery mechanisms

Q2 2026: Mobile MVP

[ ] iOS and Android apps
[ ] Basic wallet functionality
[ ] Session management UI
[ ] Import browser

Q3 2026: Enhanced Features

[ ] Weshnet research integration
[ ] Advanced permissions
[ ] Social recovery
[ ] Service marketplace

Q4 2026: Edge Computing

[ ] Run light services on device
[ ] Local-first with sync
[ ] Mesh network testing

The Bigger Picture

Why This Matters

Accessibility: Not everyone has reliable internet
Privacy: Not all compute should be public
Resilience: Networks fail, services shouldn’t
Sovereignty: Your device, your data, your rules

Integration Benefits

Weshnet + Amigos: Distributed compute meets distributed networking
Mobile + Sessions: Security meets usability
Edge + Cloud: Best of both worlds

Imagine opening your phone in a remote village, paying for goods with a local mesh network, running a small business on imported services, all without internet. That’s the power of edge-enabled Amigos.

Questions

How do we handle state conflicts in offline-first scenarios?
What’s the right permission granularity for sessions?
How do we make mesh networking intuitive for users?
Should edge nodes earn rewards like validators?
Can we make offline transactions truly trustless?

Next Steps

Prototype session system
Design mobile wallet UI/UX
Research Weshnet integration points
Build offline state reconciliation
Test mesh network scenarios

The edge isn’t the future - it’s where real users live today.

edge-networking