convez.ai
MCP ServerSegurançaAvançado
Sorcha-Platform

Sorcha — Plataforma de Registro Descentralizado com Criptografia

Sorcha-Platform/Sorcha

Infraestrutura de registro descentralizado com prova criptográfica para workflows multi-party

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server para orquestração segura de fluxos de dados multi-participantes com garantias criptográficas. Oferece blueprints declarativos, registros distribuídos imutáveis, carteiras HD com suporte a criptografia pós-quântica (ML-DSA/ML-KEM), criptografia em nível de campo e integração nativa com assistentes de IA.

Instalação

$npx convez-ai Sorcha-Platform/Sorcha

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
87%
Último commit
há 1 mês
Versão
—
Issues abertas
43
Contribuidores
4

Casos de uso

  • Orquestração de fluxos de dados entre múltiplos participantes com auditoria criptográfica
  • Implementação de credenciais verificáveis (SD-JWT VC, OpenID4VCI/VP)
  • Plataformas de compliance e governança que exigem imutabilidade de registros
  • Redes peer-to-peer com replicação segura e validação de transações

Veredito

Plataforma robusta e madura para infraestrutura de dados descentralizada com suporte enterprise a criptografia pós-quântica e workflows complexos. Exige expertise avançada em segurança, criptografia e arquitetura distribuída — não é ferramenta plug-and-play.

README

A tradução para o português deste README ainda está na fila.

Sorcha

NuGet CI Docker CI CodeQL License: MIT

A decentralised register platform for secure, multi-participant data flow orchestration.

Sorcha lets organizations define structured workflows — called blueprints — where multiple parties exchange, validate, and record data with cryptographic guarantees. Every transaction is signed, every change is immutable, and every participant sees only what they're authorized to access.

What Sorcha Does

CapabilityDescription
Blueprint WorkflowsDefine multi-step, multi-party data flows as declarative JSON with conditional routing, schema validation, and business logic evaluation
Distributed LedgerImmutable, append-only transaction registers with chain validation, Merkle-tree dockets, and DID URI addressing
Cryptographic WalletsHD wallet management (BIP32/39/44) with ED25519, P-256, RSA-4096, and post-quantum algorithms (ML-DSA, ML-KEM, SLH-DSA)
Field-Level EncryptionEnvelope encryption with per-recipient key wrapping — participants see only the fields they're authorized to access
Multi-Tenant IdentityJWT authentication with OAuth2 client credentials, participant identity registry, and wallet address linking
Peer NetworkgRPC-based P2P topology for register replication across nodes
Real-Time NotificationsSignalR hubs for live action notifications, inbound transaction alerts, and workflow state changes
AI IntegrationMCP Server for AI assistant interaction + AI-assisted blueprint design in the rail-driven Describe → Understand → Rehearse → Go-live designer

The DAD Security Model

Sorcha implements DAD (Disclosure, Alteration, Destruction):

  • Disclosure — Field-level encryption and selective disclosure via JSON Pointers ensure participants see only what they're authorized to access
  • Alteration — Every data change is recorded as a cryptographically signed transaction on an immutable ledger
  • Destruction — Peer network replication eliminates single-point-of-failure data loss

Quick Start

For the full quickstart (every prerequisite with version constraint, every common failure mode with documented fix, the verify-installation curl), see docs/quickstart.md. That document is agent-runnable end-to-end and is the canonical setup reference.

The short version:

Prerequisites

  • Docker Engine ≥ 24 (or Docker Desktop on macOS / Windows)
  • Docker Compose v2 (the docker compose plugin — v1 standalone is end-of-life and rejected by the setup script)
  • OpenSSL or Python 3 (for JWT key generation)
  • Git
  • PowerShell 7.5+ (optional — only needed for walkthroughs/)

Ports 80, 443, and 8080 must be free.

Setup

git clone https://github.com/Sorcha-Platform/Sorcha.git
cd Sorcha

# Interactive setup — checks prerequisites, generates .env, pulls images, starts services
./scripts/sorcha-setup.sh

# Or manual setup:
cp .env.example .env          # Edit with your settings
docker compose up -d          # Start all services

On success the script prints [sorcha-setup] success — gateway reachable at http://localhost. Verify with curl -s http://localhost/api/health — every service should report Healthy.

Access Points

ServiceURLDescription
Sorcha UIhttp://localhost/appMain application interface
Blueprint Designerhttp://localhost/app/designer/blueprintRail-driven designer — Describe → Understand → Rehearse → Go live (Feature 142)
API Gatewayhttp://localhost/REST API entry point
API Documentationhttp://localhost/scalar/Interactive Scalar API docs
Health Checkhttp://localhost/api/healthAggregated service health
Aspire Dashboardhttp://localhost:18888Observability and telemetry

Default Credentials

After first run, the system creates a default organization and admin user:

FieldValue
Emailadmin@sorcha.local
PasswordDev_Pass_2025!

Change these immediately in production. See Authentication Setup for production configuration.

How It Works

1. Define a Blueprint

Blueprints are JSON documents that describe multi-party workflows:

{
  "title": "Invoice Approval",
  "description": "Two-party invoice submission and approval",
  "participants": [
    { "id": "submitter", "name": "Submitter" },
    { "id": "approver", "name": "Approver" }
  ],
  "actions": [
    {
      "id": 0,
      "title": "Submit Invoice",
      "sender": "submitter",
      "isStartingAction": true,
      "dataSchemas": [
        { "type": "object", "properties": { "amount": { "type": "number" } }, "required": ["amount"] }
      ],
      "routes": [{ "id": "to-review", "nextActionIds": [1], "isDefault": true }],
      "disclosures": [{ "participantAddress": "submitter", "dataPointers": ["/*"] }]
    },
    {
      "id": 1,
      "title": "Review Invoice",
      "sender": "approver",
      "dataSchemas": [
        { "type": "object", "properties": { "decision": { "type": "string", "enum": ["approved", "rejected"] } }, "required": ["decision"] }
      ],
      "routes": [{ "id": "done", "nextActionIds": [], "isDefault": true }],
      "disclosures": [{ "participantAddress": "approver", "dataPointers": ["/*"] }]
    }
  ]
}

Flow uses routes[] (nextActionIds → action ids; [] ends the workflow); one action is the open isStartingAction; every action declares disclosures. See the Blueprint Designer and blueprint-builder skill.

See the blueprints/ directory for ready-to-use templates across finance, healthcare, supply chain, and government domains.

2. Publish to a Register

Blueprints are published to registers — distributed ledgers that record every transaction immutably. Each register has its own chain of cryptographically signed dockets.

3. Execute the Workflow

Participants complete actions in sequence. The engine validates schemas, evaluates business logic, routes to the next participant, and records everything on the ledger.

4. Verify and Audit

Every transaction is signed, timestamped, and chained. The full history is available via the REST API or CLI tool.

CLI Tool

The sorcha CLI provides administrative access to the platform:

# Authenticate
sorcha auth login

# Manage organizations
sorcha org list
sorcha org create --name "Acme Corp" --subdomain acme

# Wallet operations
sorcha wallet list
sorcha wallet create --name "Signing Key" --algorithm ED25519

# Register and transaction management
sorcha register list
sorcha tx submit --register-id reg-123 --payload '{"type":"invoice","amount":1500}'

See the CLI documentation for the full command reference.

Architecture Overview

graph TD
    UI["Sorcha UI<br/><small>Blazor WASM</small>"]
    GW["API Gateway<br/><small>YARP Reverse Proxy</small>"]

    BP["Blueprint Service<br/><small>Workflows + SignalR</small>"]
    REG["Register Service<br/><small>Distributed Ledger</small>"]
    TEN["Tenant Service<br/><small>Auth + Identity</small>"]
    WAL["Wallet Service<br/><small>Crypto + Signing</small>"]
    VAL["Validator Service<br/><small>Consensus + Dockets</small>"]
    PEER["Peer Service<br/><small>gRPC Replication</small>"]

    PG1[(PostgreSQL)]
    PG2[(PostgreSQL)]
    MONGO[(MongoDB)]
    REDIS[(Redis)]

    UI --> GW
    GW --> BP
    GW --> REG
    GW --> TEN

    BP --> WAL
    REG --> VAL
    VAL --> PEER

    BP --- PG1
    TEN --- PG2
    WAL --- PG2
    REG --- MONGO
    VAL --- REDIS
    BP -. SignalR .-> UI
ServicePurpose
API GatewayYARP reverse proxy — single entry point for all API traffic
Blueprint ServiceWorkflow management, execution engine, SignalR notifications
Register ServiceDistributed ledger, transaction storage, OData queries
Wallet ServiceCryptographic key management, signing, encryption
Tenant ServiceMulti-tenant auth, JWT issuer, participant identity
Validator ServiceTransaction validation, consensus, docket building
Peer ServiceP2P network topology, gRPC replication

Configuration

All configuration is managed through environment variables. See .env.example for a fully documented template with every variable explained.

Key settings:

VariablePurposeDefault
JWT_SIGNING_KEY256-bit key for JWT tokensGenerated by setup script
POSTGRES_USER / POSTGRES_PASSWORDPostgreSQL credentialssorcha / sorcha_dev_password
MONGO_USERNAME / MONGO_PASSWORDMongoDB credentialssorcha / sorcha_dev_password
ANTHROPIC_API_KEYAI blueprint design (optional)Empty

For AI Agents and Integrators

Sorcha publishes a machine-readable surface so AI agents, AI coding assistants, and integrators picking up the platform can find, parse, and reason over it without out-of-band documentation. The four published documents are the canonical agent-facing reference and live alongside the standards file and the well-known endpoints:

SurfacePurpose
llms.txtOne-screen factual summary, llmstxt.org-conforming
STANDARDS.mdSingle source of truth for every standard the platform implements
docs/quickstart.mdAgent-runnable setup against a clean Docker host
docs/architecture.mdArchitectural overview — services, evidence flow, discovery surface
docs/openid4vc-haip-integration.mdWallet ecosystem boundary (OpenID4VCI / OpenID4VP / HAIP 1.0)
docs/applicability.mdRegulatory-pull domains (DPP, trade finance, IPC-1782, municipal)
docs/security-model.mdSelective disclosure, post-quantum posture, honest gaps
docs/mcp-server.mdConnecting an AI agent via the Model Context Protocol
docs/llms-full.txtLong-form machine-readable narrative
GET /.well-known/openapi.json (running gateway)Aggregated OpenAPI 3.1 surface with info.x-mcp-server and info.x-standards
GET /.well-known/openapi.yaml (running gateway)YAML form of the same document
GET /.well-known/mcp.json (running gateway)MCP server manifest — transports, authentication, tool catalogue

These surfaces are gated by the ai-discoverability-check CI workflow on every pull request to master.

Documentation

DocumentDescription
Docker Quick StartGetting started with Docker
Authentication SetupJWT and auth configuration
API DocumentationREST and gRPC endpoint reference
Blueprint Quick StartCreating your first blueprint
Port ConfigurationService ports and networking
ArchitectureSystem design and data flows
Deployment GuideProduction deployment
TroubleshootingCommon issues and solutions

Walkthroughs

Interactive demos in the walkthroughs/ directory:

WalkthroughDescription
BlueprintStorageBasic/Docker startup, bootstrap, JWT authentication
PingPong/Simple two-party workflow
ConstructionPermit/Multi-step approval process
MedicalEquipmentRefurb/Healthcare equipment workflow
OrganizationPingPong/Multi-organization data exchange
RegisterCreationFlow/Register lifecycle management

See walkthroughs/README.md for the full list and setup instructions.

Development

For building from source, running tests, project structure, coding conventions, and contributing — see DEVELOPMENT.md.

License

MIT License — see LICENSE for details.

Links


Built with .NET 10 and .NET Aspire

Ver o original no GitHub

Bom para

Relacionados