feat: full Web3 capability surface + modular communications

Expands the platform from 30 blockchain services to 221 discrete Web3
capabilities, data-driven through a single catalog file. Adds 9
pluggable notification channels with a modular, re-runnable setup wizard.
The paymaster pattern (platform pays gas) is preserved bit-for-bit.

CAPABILITY FRAMEWORK
  runtime/capabilities/
    __init__.py         — exposes CapabilityRegistry + catalog
    catalog.py          — single source of truth: 221 capability entries
                          across 21 categories (contracts, DeFi, DeFi
                          Advanced, NFT, NFT Finance, Identity, Governance,
                          Social, Creator, Payments, Bridging, Staking,
                          Privacy, Oracles, Storage, Compute, Real-world,
                          Markets, Security, Gaming, Infrastructure).
                          Every entry carries service/method/action mapping,
                          params schema, paymaster flag, min_tier, protocol.
                          Exposes install_action_map() which merges catalog
                          entries into the existing dispatcher dicts without
                          overwriting anything (refuses on conflict).
    registry.py         — CapabilityRegistry facade: list_capabilities,
                          list_by_category, describe(id), async invoke(id).

  runtime/blockchain/services/service_dispatcher.py
                          Install hook merges catalog into ACTION_MAP,
                          _STATE_MODIFYING_ACTIONS, ACTION_TO_FEED_EVENT
                          at module import. Trinity's platform_action tool
                          now exposes all 221 capabilities automatically.

NEW SERVICES (14 stubs covering missing Web3 surface)
  restaking/            EigenLayer, Symbiotic, Karak, Lido, Rocket Pool
  mpc/                  Threshold sigs, social recovery, session keys
  tba/                  ERC-6551 token-bound accounts
  auctions/             Dutch/English/sealed-bid + orderbook DEX
  nft_lending/          BendDAO, NFTfi, Arcade, breeding
  compute/              Akash, Gensyn, Render, DePIN
  storage/              Filecoin, Ceramic, OrbitDB
  ccip/                 CCIP, Hyperlane, Wormhole, Axelar, Stargate
  creator_platforms/    Sound.xyz, Mirror, Paragraph
  social_protocols/     Lens, Farcaster, Push Protocol, social/creator tokens
  advanced_governance/  veToken, quadratic, RetroPGF, bribes
  oracles_plus/         Pyth, RedStone, API3, Chainlink Keepers
  kyc/                  Sumsub, Persona, self-sovereign KYC credentials
  payment_channels/     Raiden-style state channels

  Each service follows the duck-typed pattern, returns
  not_deployed_response() until real integrations land, and lazy-creates
  a GasSponsor instance so transactions route through the existing
  paymaster.

GATEWAY CAPABILITY ENDPOINTS
  GET  /api/v1/capabilities                     list + optional filters
  GET  /api/v1/capabilities/categories          counts per category
  GET  /api/v1/capabilities/{id}                descriptor
  POST /api/v1/capabilities/{id}/invoke         generic invoker

NOTIFICATIONS (9 pluggable channels)
  runtime/notifications/
    base.py             Channel ABC (send, available, enabled)
    dispatcher.py       NotificationDispatcher: fan-out, legacy config
                        migration, test_channel() helper
    telegram.py         Bot messaging with Markdown
    discord.py          Webhook with color-coded embeds
    slack.py            Incoming webhook
    email_smtp.py       SMTP with STARTTLS/SSL
    sms_twilio.py       Twilio REST
    whatsapp_twilio.py  Twilio WhatsApp
    web_chat.py         Live SSE feed into built-in web UI
    ios_push.py         APNs for MTRX iOS
    webhook.py          Generic JSON POST

MODULAR SETUP WIZARD
  setup/                  Per-channel re-runnable configurators
    _shared.py            Shared helpers (ask, save, update_env, test)
    telegram.py           Auto-discovers chat_id by waiting for first msg
    discord.py, slack.py, email.py, sms.py, whatsapp.py,
    web_chat.py, ios_push.py, webhook.py
  setup_communications.py Interactive menu + CLI:
                          `python setup_communications.py`
                          `python setup_communications.py telegram`
                          `python setup_communications.py --list`
  setup_telegram.py       Backwards-compat shim
  setup.py                configure_communications() now delegates to
                          setup/*.py per channel, supports all 9

CONFIG + VALIDATION
  openmatrix.config.json.example
                         Full notifications block with 9 channels + 14
                         new service stubs. Removed legacy referrals/
                         metered_api blocks (moved to MTRX iOS).
  runtime/config/validation.py
                         Added secret fields for all notification channels.

MTRX EXTENSIONS REGISTRY
  extensions/registry.json
                         Regenerated from catalog (v2.0.0). 20 components,
                         221 capabilities exposed to the iOS app.

NET STATS
  Capabilities:   30 services → 221 capabilities
  Categories:     1 flat list → 21 categories
  Services:       30 → 44 (14 new stubs)
  ACTION_MAP:     150 → 280 entries (0 conflicts)
  Channels:       4 → 9 (+ SMS, WhatsApp, Slack, Web chat, iOS push)
  Setup wizard:   monolithic → modular + re-runnable
  Files compile:  all 40 modified/new files pass py_compile
  Paymaster:      unchanged — zero edits to gas_sponsor.py

Author: Neo

extensions/registry.json

@@ -368,12 +368,18 @@ def register_routes(self, app: web.Application) -> None:
         app.router.add_post("/api/v1/privacy/transfer", self._handle_private_transfer)
         app.router.add_post("/api/v1/privacy/stealth-address", self._handle_stealth_address)
 
+        # ── Capability Registry (data-driven Web3 capability surface) ──
+        app.router.add_get("/api/v1/capabilities",                    self._handle_capabilities_list)
+        app.router.add_get("/api/v1/capabilities/categories",         self._handle_capabilities_categories)
+        app.router.add_get("/api/v1/capabilities/{capability_id}",    self._handle_capability_detail)
+        app.router.add_post("/api/v1/capabilities/{capability_id}/invoke", self._handle_capability_invoke)
+
         # Batch dispatch and live event stream (used by MTRXPackager)
         app.router.add_post("/api/v1/batch", self._handle_batch)
         app.router.add_get("/api/v1/events/stream", self._handle_event_stream)
 
         self._build_batch_route_map()
-        logger.info("ServiceRoutes: registered %d endpoints", 118)
+        logger.info("ServiceRoutes: registered %d endpoints", 122)
 
     # ------------------------------------------------------------------
     # Batch route map — mirrors every non-batch route above so we can
@@ -1870,6 +1876,62 @@ async def _handle_stealth_address(self, request: web.Request) -> web.Response:
         )
         return self._ok(result)
 
+    # ------------------------------------------------------------------
+    # Capability Registry (data-driven Web3 capability surface)
+    # ------------------------------------------------------------------
+
+    def _capability_registry(self):
+        """Lazy-load the CapabilityRegistry with the gateway's config."""
+        reg = getattr(self, "_cap_registry_cache", None)
+        if reg is None:
+            from runtime.capabilities import CapabilityRegistry
+            reg = CapabilityRegistry(self._config)
+            self._cap_registry_cache = reg
+        return reg
+
+    async def _handle_capabilities_list(self, request: web.Request) -> web.Response:
+        """``GET /api/v1/capabilities`` — enumerate all capabilities."""
+        reg = self._capability_registry()
+        category = request.query.get("category")
+        min_tier = request.query.get("min_tier")
+        available_only = request.query.get("available", "").lower() in {"1", "true", "yes"}
+        caps = reg.list_capabilities(
+            category=category,
+            available_only=available_only,
+            min_tier=min_tier,
+        )
+        return self._ok({"capabilities": caps, "count": len(caps)})
+
+    async def _handle_capabilities_categories(self, request: web.Request) -> web.Response:
+        """``GET /api/v1/capabilities/categories`` — list categories + counts."""
+        reg = self._capability_registry()
+        return self._ok({"categories": reg.list_categories()})
+
+    async def _handle_capability_detail(self, request: web.Request) -> web.Response:
+        """``GET /api/v1/capabilities/{id}`` — descriptor for one capability."""
+        capability_id = request.match_info["capability_id"]
+        reg = self._capability_registry()
+        cap = reg.describe(capability_id)
+        if cap is None:
+            return web.json_response(
+                {"ok": False, "error": "unknown_capability", "capability_id": capability_id},
+                status=404,
+            )
+        return self._ok({"capability": cap})
+
+    async def _handle_capability_invoke(self, request: web.Request) -> web.Response:
+        """``POST /api/v1/capabilities/{id}/invoke`` — execute a capability."""
+        capability_id = request.match_info["capability_id"]
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+        params = body.get("params", {}) if isinstance(body, dict) else {}
+        reg = self._capability_registry()
+        result = await reg.invoke(capability_id, params)
+        status = 200 if result.get("status") == "ok" else 400
+        return web.json_response(result, status=status)
+
     # ------------------------------------------------------------------
     # Batch dispatch
     # ------------------------------------------------------------------

gateway/service_routes.py

@@ -91,8 +91,60 @@
   },
   "notifications": {
     "telegram": {
+      "enabled": false,
       "bot_token": "YOUR_TELEGRAM_BOT_TOKEN",
+      "chat_id": "YOUR_TELEGRAM_CHAT_ID",
       "owner_id": "YOUR_TELEGRAM_USER_ID"
+    },
+    "discord": {
+      "enabled": false,
+      "webhook_url": "YOUR_DISCORD_WEBHOOK_URL",
+      "username": "0pnMatrx"
+    },
+    "slack": {
+      "enabled": false,
+      "webhook_url": "YOUR_SLACK_WEBHOOK_URL"
+    },
+    "email": {
+      "enabled": false,
+      "smtp_host": "smtp.gmail.com",
+      "smtp_port": 587,
+      "smtp_user": "YOUR_SMTP_USER",
+      "smtp_pass": "YOUR_SMTP_APP_PASSWORD",
+      "from": "YOUR_SMTP_USER",
+      "to": "YOUR_NOTIFICATION_EMAIL",
+      "use_ssl": false
+    },
+    "sms": {
+      "enabled": false,
+      "account_sid": "YOUR_TWILIO_ACCOUNT_SID",
+      "auth_token": "YOUR_TWILIO_AUTH_TOKEN",
+      "from_number": "+15551234567",
+      "to_number": "+15559876543"
+    },
+    "whatsapp": {
+      "enabled": false,
+      "account_sid": "YOUR_TWILIO_ACCOUNT_SID",
+      "auth_token": "YOUR_TWILIO_AUTH_TOKEN",
+      "from_number": "+14155238886",
+      "to_number": "+15551234567"
+    },
+    "web_chat": {
+      "enabled": true
+    },
+    "ios_push": {
+      "enabled": false,
+      "auth_key_p8": "",
+      "key_id": "YOUR_APNS_KEY_ID",
+      "team_id": "YOUR_APPLE_TEAM_ID",
+      "bundle_id": "com.opnmatrx.mtrx",
+      "sandbox": false,
+      "device_tokens": []
+    },
+    "webhook": {
+      "enabled": false,
+      "url": "YOUR_WEBHOOK_URL",
+      "bearer_token": ""
     }
   },
   "services": {
@@ -284,15 +336,21 @@
       "enabled": true,
       "contract_address": "YOUR_X402_PAYMENTS_CONTRACT_ADDRESS",
       "supported_tokens": ["USDC", "ETH"]
-    }
-  },
-  "referrals": {
-    "enabled": true,
-    "pro_referral_months": 1,
-    "enterprise_referral_months": 2
-  },
-  "metered_api": {
-    "enabled": true
+    },
+    "restaking":            {"enabled": false},
+    "mpc":                  {"enabled": false},
+    "tba":                  {"enabled": false},
+    "auctions":             {"enabled": false},
+    "nft_lending":          {"enabled": false},
+    "compute":              {"enabled": false},
+    "storage":              {"enabled": false},
+    "ccip":                 {"enabled": false},
+    "creator_platforms":    {"enabled": false},
+    "social_protocols":     {"enabled": false},
+    "advanced_governance":  {"enabled": false},
+    "oracles_plus":         {"enabled": false},
+    "kyc":                  {"enabled": false},
+    "payment_channels":     {"enabled": false}
   },
   "protocol_referrals": {
     "enabled": true,

openmatrix.config.json.example

@@ -0,0 +1,4 @@
+"""veToken locks, quadratic voting, RetroPGF, gauge bribes, voting delegation."""
+from runtime.blockchain.services.advanced_governance.service import AdvancedGovernanceService
+
+__all__ = ["AdvancedGovernanceService"]

runtime/blockchain/services/advanced_governance/__init__.py

@@ -0,0 +1,75 @@
+"""
+veToken locks, quadratic voting, RetroPGF, gauge bribes, voting delegation.
+
+This service is a stub until real protocol integrations are wired in.
+Every method returns the canonical not_deployed_response until the
+backend contracts / adapter SDKs are configured. Once the platform
+operator populates the relevant config keys, individual methods can
+swap their bodies for the real implementation without changing the
+service interface.
+
+All state-modifying methods MUST route on-chain transactions through
+``runtime.blockchain.gas_sponsor.GasSponsor`` so the platform pays gas.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from runtime.blockchain.web3_manager import Web3Manager, not_deployed_response
+
+logger = logging.getLogger(__name__)
+
+
+class AdvancedGovernanceService:
+    """veToken locks, quadratic voting, RetroPGF, gauge bribes, voting delegation."""
+
+    service_name = "advanced_governance"
+
+    def __init__(self, config: dict) -> None:
+        self._config = config
+        self._web3 = Web3Manager.get_shared(config)
+        self._gas_sponsor = None  # lazy — only instantiated when needed
+
+    def _sponsor(self):
+        if self._gas_sponsor is None:
+            from runtime.blockchain.gas_sponsor import GasSponsor
+            self._gas_sponsor = GasSponsor(self._config)
+        return self._gas_sponsor
+
+    async def vote_escrow(self, **params: Any) -> dict:
+        """Stub for vote_escrow. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "vote_escrow", "params": params},
+        )
+
+    async def quadratic_vote(self, **params: Any) -> dict:
+        """Stub for quadratic_vote. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "quadratic_vote", "params": params},
+        )
+
+    async def submit_retropgf(self, **params: Any) -> dict:
+        """Stub for submit_retropgf. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "submit_retropgf", "params": params},
+        )
+
+    async def place_bribe(self, **params: Any) -> dict:
+        """Stub for place_bribe. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "place_bribe", "params": params},
+        )
+
+    async def delegate_voting(self, **params: Any) -> dict:
+        """Stub for delegate_voting. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "delegate_voting", "params": params},
+        )
+

runtime/blockchain/services/advanced_governance/service.py

@@ -0,0 +1,4 @@
+"""Dutch, English, sealed-bid auctions and orderbook DEX primitives."""
+from runtime.blockchain.services.auctions.service import AuctionService
+
+__all__ = ["AuctionService"]

runtime/blockchain/services/auctions/__init__.py

@@ -0,0 +1,75 @@
+"""
+Dutch, English, sealed-bid auctions and orderbook DEX primitives.
+
+This service is a stub until real protocol integrations are wired in.
+Every method returns the canonical not_deployed_response until the
+backend contracts / adapter SDKs are configured. Once the platform
+operator populates the relevant config keys, individual methods can
+swap their bodies for the real implementation without changing the
+service interface.
+
+All state-modifying methods MUST route on-chain transactions through
+``runtime.blockchain.gas_sponsor.GasSponsor`` so the platform pays gas.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from runtime.blockchain.web3_manager import Web3Manager, not_deployed_response
+
+logger = logging.getLogger(__name__)
+
+
+class AuctionService:
+    """Dutch, English, sealed-bid auctions and orderbook DEX primitives."""
+
+    service_name = "auctions"
+
+    def __init__(self, config: dict) -> None:
+        self._config = config
+        self._web3 = Web3Manager.get_shared(config)
+        self._gas_sponsor = None  # lazy — only instantiated when needed
+
+    def _sponsor(self):
+        if self._gas_sponsor is None:
+            from runtime.blockchain.gas_sponsor import GasSponsor
+            self._gas_sponsor = GasSponsor(self._config)
+        return self._gas_sponsor
+
+    async def create_auction(self, **params: Any) -> dict:
+        """Stub for create_auction. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "create_auction", "params": params},
+        )
+
+    async def place_bid(self, **params: Any) -> dict:
+        """Stub for place_bid. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "place_bid", "params": params},
+        )
+
+    async def settle_auction(self, **params: Any) -> dict:
+        """Stub for settle_auction. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "settle_auction", "params": params},
+        )
+
+    async def place_limit_order(self, **params: Any) -> dict:
+        """Stub for place_limit_order. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "place_limit_order", "params": params},
+        )
+
+    async def cancel_limit_order(self, **params: Any) -> dict:
+        """Stub for cancel_limit_order. Returns not_deployed until the adapter is wired."""
+        return not_deployed_response(
+            self.service_name,
+            extra={"method": "cancel_limit_order", "params": params},
+        )
+

runtime/blockchain/services/auctions/service.py

@@ -0,0 +1,4 @@
+"""Cross-chain messaging and bridging via CCIP, Hyperlane, Wormhole, Axelar, Stargate."""
+from runtime.blockchain.services.ccip.service import CrossChainMessagingService
+
+__all__ = ["CrossChainMessagingService"]