Argos — Blockchain-Plattform für Asset-Tracing

Argos ist eine in mehreren Programmiersprachen entwickelte Blockchain-Ermittlungsplattform zur Verfolgung, Analyse und Visualisierung von Geldflüssen auf Ethereum und Bitcoin. Entwickelt mit Rust, OCaml und TypeScript/React.

Architektur

                     +-----------------------+
                     |  Frontend (React 19)  |
                     |  Vite + Tailwind CSS  |
                     +-----------+-----------+
                                 | HTTP/REST
                     +-----------v-----------+
                     |    REST API (Rust)    |
                     |   Axum — port 8990   |
                     |                       |
                     | in-process OCaml FFI  |
                     | (ocaml-interop):      |
                     |  database_ffi.so —    |
                     |  tracing + full decode|
                     +-----------+-----------+
                                 |
         +-----------------------v----------------------+
         |             PostgreSQL (11 DBs)              |
         |                   Redis                      |
         +----------------------------------------------+

  +------------------+          +------------------+
  | Ethereum node    |          | Bitcoin node     |
  +--------+---------+          +--------+---------+
           |                             |
  +--------v----------+        +--------v----------+
  | Rust indexers x2  |        | Rust indexers x2  |
  | (psql x           |        | (psql x           |
  |  latest/hist)     |        |  latest/hist)     |
  |                   |        |                   |
  | in-process OCaml  |        | in-process OCaml  |
  | FFI: analyses_ffi |        | FFI: analyses_ffi |
  | .so (decode +     |        | .so (decode +     |
  | defi_analyses)    |        | defi_analyses)    |
  +-------------------+        +-------------------+

Decode, DeFi-Analysen und Tracing laufen prozessintern in den Rust-Binaries über eine direkte Rust↔OCaml-FFI (ocaml-interop) — es gibt keine separaten Microservices und keine gRPC-Ports.

Schnellstart

Vollständige Einrichtungsanweisungen findest du unter Erste Schritte.

git clone [email protected]:functori/argos/argos.git
cd argos
cp argos.secret.env.example argos.secret.env  # Fill in secrets
set -o allexport && . ./argos.env && . ./argos.secret.env && set +o allexport
make install-deps
make create-tablespaces
make migrate-databases
make build

Dokumentation

Dokument	Beschreibung
Erste Schritte	Voraussetzungen, Installation, erster Start
Architektur	Systemtopologie und Datenflüsse
REST API	API-Endpunkte und Authentifizierung
Indexer	Blockchain-Indexer-Binaries
Datenbank	Datenbankschemata und Partitionierung
Bereitstellung	Docker, Dienste, Logs, Monitoring
Docker	Docker-Images pro Dienst, Build-Rezepte, Laufzeitkonfiguration
Umgebung	Referenz der Umgebungsvariablen
Tracing	Algorithmus zur Verfolgung von Geldflüssen
Decode und Analyse	Decode und Analyse (prozessinterne OCaml-FFI)
OSINT	OSINT-Datenquellen und -Erfassung
Analyse-Algorithmen	DeFi-Analyse (Arbitrage, Sandwich, usw.)
Clustering	Adress-Clustering und Klassifikations-Pipeline
Decode-Komponente	ABI-Decodierung
Frontend	React-Anwendung

Entwicklung

Siehe Entwicklerkonventionen:

Git-Workflow — Projektplanung, Commits, MRs, Reviews
Code-Richtlinien — Stil- und Qualitätsstandards
Quellcode-Organisation — Wo der Code abgelegt wird

Build

make install-deps      # Install all dependencies (OCaml, Rust, Node, Python)
make build             # Build backend (Rust + OCaml)
make build-front       # Build frontend
make create-tablespaces  # Create PostgreSQL tablespace directories
make migrate-databases   # Create databases and run migrations
make run-tests           # Run tests
make lint-backend        # Lint backend (clippy, ocamlformat)
make lint-frontend       # Lint frontend (eslint)
make format            # Auto-format all code

Lizenz

Proprietär — Functori

Argos — Updated!

Kategorien