7aychain
Layer 1 blockchain with on-chain Proof of Presence — validators triangulate physical presence through network latency, no GPS required.
Install / Use
/learn @7ayLabs/7aychainREADME
7aychain is a Layer 1 blockchain built to answer one question: is this actor actually here? Validators form witness circles, measure network latency between peers, and triangulate positions — no GPS, no external oracles, no special hardware. Presence is verified through the protocol itself and finalized on-chain with quorum consensus.
The chain runs on the 7ay Proof of Presence Protocol, where every presence declaration goes through an epoch-bound lifecycle: declared, attested by witnesses, triangulated, and finalized by validators.
Website · Contributing · Security · License
Get running in three commands — clone, build, and start a local devnet. Then use the Laud Networks CLI to interact with every module on the chain.
git clone https://github.com/7ayLabs/7aychain.git && cd 7aychain
cargo build --release
./target/release/seveny-node --dev
Building the Source
Building 7aychain requires a Rust toolchain, Clang/LLVM, and protobuf.
Prerequisites
Install Rust and the WASM target:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-unknown-unknown
Then install platform-specific dependencies:
<details> <summary><b>macOS</b></summary>brew install llvm cmake protobuf
sudo apt-get update
sudo apt-get install -y clang libclang-dev protobuf-compiler pkg-config cmake build-essential
sudo dnf install clang clang-devel protobuf-compiler cmake pkg-config
Install Visual Studio Build Tools with the "C++ build tools" workload, then:
choco install llvm cmake protoc
Or with Scoop:
scoop install llvm cmake protobuf
Clone and Build
git clone https://github.com/7ayLabs/7aychain.git
cd 7aychain
cargo build --release
The binary is located at ./target/release/seveny-node.
Running Tests
cargo test --workspace
Hardware Requirements
| | Minimum | Recommended | |---|---------|-------------| | CPU | 4 cores | 8+ cores | | RAM | 8 GB | 16 GB | | Storage | 50 GB SSD | 100 GB NVMe SSD | | Network | 10 Mbit/s | 25+ Mbit/s |
Validators running witness-circle triangulation and ZK verification benefit from higher single-thread performance. Apple Silicon (M1 Pro/Max/Ultra) and modern x86-64 (AMD Zen 3+, Intel 12th gen+) are well suited.
Running 7aychain
Development Node
Start a single-node dev chain with instant-seal and pre-funded accounts (Alice, Bob, Charlie, Dave, Eve, Ferdie):
./target/release/seveny-node --dev
With debug logging:
RUST_LOG=debug ./target/release/seveny-node --dev
Single Node
Run a single validator on the local testnet:
./target/release/seveny-node \
--alice \
--validator \
--chain local \
--base-path /tmp/alice \
--rpc-port 9944 \
--rpc-cors all \
--rpc-methods unsafe \
--scanner-mode mock \
--mock-devices 15
Multi-Node Devnet
Run the full network with Alice natively and the remaining validators in Docker:
# 1. Start Alice natively (real or mock scanning)
devnet/scripts/run-native-alice.sh
# 2. Start Bob, Charlie, Dave, Eve, Ferdie in Docker
cd devnet
docker compose -f docker-compose.hybrid.yml up -d
# 3. Monitor the network
devnet/scripts/monitor.sh
Each node gets its own RPC port:
| Node | RPC Port | P2P Port | |------|----------|----------| | Alice (native) | 9944 | 30333 | | Bob | 9945 | 30334 | | Charlie | 9946 | 30335 | | Dave | 9947 | 30336 | | Eve | 9948 | 30337 | | Ferdie | 9949 | 30338 |
Stop and reset:
docker compose -f docker-compose.hybrid.yml down # stop Docker nodes
docker compose -f docker-compose.hybrid.yml down -v # stop + clear chain state
Configuration
| Flag | Description |
|------|-------------|
| --dev | Run in development mode with temporary storage |
| --chain <spec> | Chain specification (dev, local) |
| --validator | Enable validator mode |
| --base-path <path> | Database and keystore location |
| --rpc-port <port> | JSON-RPC port — serves both HTTP and WebSocket (default: 9944) |
| --rpc-cors <origins> | Allowed RPC origins (all for development) |
| --rpc-methods <mode> | RPC method set (safe, unsafe) |
| --rpc-external | Listen on all interfaces (0.0.0.0) |
| --port <port> | P2P network port (default: 30333) |
| --name <name> | Node display name |
| --scanner-mode <mode> | Device scanner mode (latency, mock) |
| --mock-devices <n> | Number of simulated devices in mock mode |
| --scan-interval <secs> | Seconds between device scans (default: 6) |
| --scanner-pos-x/y/z <n> | Scanner position coordinates |
Docker
Quick start with a single instant-seal devnet node:
cd devnet
docker compose -f docker-compose.dev.yml up -d --build
Blocks are produced only when extrinsics are submitted.
| Port | Service |
|------|---------|
| 9944 | JSON-RPC (HTTP + WebSocket) |
| 30333 | P2P |
Stop and reset:
docker compose -f docker-compose.dev.yml down # stop
docker compose -f docker-compose.dev.yml down -v # stop + clear chain state
Devnet Scripts
All scripts are in devnet/scripts/:
| Script | Description |
|--------|-------------|
| dev.sh | Start/stop single-node devnet (Docker or native) |
| dev.sh native | Run native binary without Docker |
| dev.sh stop | Stop the Docker container |
| dev.sh reset | Stop + clear chain state |
| run-native-alice.sh | Run Alice natively with real device scanning |
| monitor.sh | Real-time health monitor for multi-node devnet |
Laud Networks CLI
Interactive testing suite for all protocol features.
Quick Start
pip install substrate-interface
python3 devnet/scripts/laud-cli.py
Connects to ws://127.0.0.1:9944 by default. Custom endpoint:
python3 devnet/scripts/laud-cli.py --url ws://host:port
Commands
| Module | Operations |
|--------|------------|
| presence | declare, commit, reveal, vote, finalize, slash, quorum |
| epoch | schedule, start, close, finalize, register, update, force |
| validator | register, activate, deactivate, withdraw, stake, slash |
| pbt | position, claim, attest, verify, setup, test |
| triangulation | multilaterate, centroid, track |
| dispute | open, evidence, vote, resolve |
| device | register, scan, trust |
| lifecycle | register, destroy, status |
| vault | create, share, recover, register-file, request-unlock, authorize-unlock |
| zk | prove, verify |
| governance | propose, vote, delegate |
| semantic | link, trust, query |
| boomerang | send, verify |
| autonomous | detect, report |
| octopus | create, join, manage |
| storage | store, retrieve, expire |
Pre-loaded accounts: alice, bob, charlie, dave, eve, ferdie.
Programmatic Access
Polkadot.js Apps
Connect the hosted Polkadot.js Apps to your local node:
Settings → Custom Endpoint → ws://127.0.0.1:9944
JSON-RPC
curl -H "Content-Type: application/json" \
-d '{"id":1, "jsonrpc":"2.0", "method":"system_health"}' \
http://127.0.0.1:9944
Subxt (Rust)
use subxt::{OnlineClient, PolkadotConfig};
let api = OnlineClient::<PolkadotConfig>::from_url("ws://127.0.0.1:9944").await?;
@polkadot/api (JavaScript)
const { ApiPromise, WsProvider } = require("@polkadot/api");
const api = await ApiPromise.create({ provider: new WsProvider("ws://127.0.0.1:9944") });
Contributing
See CONTRIBUTING.md for guidelines.
Security
See SECURITY.md for our vulnerability disclosure policy.
License
7aychain is licensed under the Business Source License 1.1.
<p align="center"> Built with <a href="https://substrate.io/">Substrate</a> by <a href="https://7aylabs.com">7ayLabs</a> </p>
Related Skills
himalaya
351.4kCLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).
node-connect
351.4kDiagnose OpenClaw node connection and pairing failures for Android, iOS, and macOS companion apps
taskflow
351.4kname: taskflow description: Use when work should span one or more detached tasks but still behave like one job with a single owner context. TaskFlow is the durable flow substrate under authoring layer
frontend-design
110.7kCreate distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
