Block Endorsements (off-chain)

This endpoint carries no consensus weight, and nothing about it is on-chain.

The signature is verified with ethers.verifyMessage inside the indexer process (yscan/indexer/src/attestations.ts), not by an on-chain ecrecover.
The accepted result is written into an off-chain SQLite table (validator_attestations), not into contract storage.
The block was already finalised by the four server validators before the phone ever saw its hash, so the signature cannot influence whether it is accepted.
The endpoint does not check the 10,000 YCE bond in ValidatorRegistry, or any other stake. An unbonded address is accepted exactly like a bonded one.

Treat it as what it is: an off-chain endorsement and liveness signal, useful for dashboards and participation counters. It is not validation.

What it actually does

The app polls the latest block (~5s) and takes its hash from eth_getBlockByNumber.
The wallet signs that hash string with EIP-191 personal_sign (wallet.signMessage(blockHash)).
POST /api/validator-attest sends { blockNumber, blockHash, signature, signerAddress }.
The indexer recovers the signer with ethers.verifyMessage and rejects the request if it does not equal signerAddress.
It re-fetches the block from the node and rejects the request if the claimed hash does not match the canonical one, or if the block is more than 200 behind head.
It inserts a row into validator_attestations — UNIQUE(block_number, attestor), so a repeat is a no-op.

Every one of those steps happens after finality, on the server, over data the server itself supplied. The signature proves the phone holds the key and echoed a hash it was given. It does not prove the phone verified anything, and it changes no on-chain state.

For the design that gives a device real, bonded, slashable weight — a light client that verifies epoch headers against the BLS validator set it tracks independently, a DeviceRegistry bond, checkpoint attestation with a fraud-proof window, and committee sampling — see docs/DEVICE-VALIDATOR-LIGHT-CLIENT.md in the repository. That document also benchmarks how Ethereum sync committees, Celo Plumo, Celestia DAS and Algorand sortition handle the same problem. Replacing this endpoint with that flow is an open item there.

Endpoints

`POST /api/validator-attest`

Submit a signed block hash. Request

curl -X POST https://api.54-237-170-237.sslip.io/api/validator-attest \
  -H 'Content-Type: application/json' \
  -d '{
    "blockNumber": 6841,
    "blockHash": "0x59fa7936abd5eb1e9d4f29dba9b797f62a815275c35892d0ce2ba26a42edb990",
    "signature": "0x...130hex...",
    "signerAddress": "0xYOUR_WALLET"
  }'

Body

Field	Type	Description
`blockNumber`	number	Non-negative integer matching an on-chain block
`blockHash`	string	`0x` + 64 hex; must match `eth_getBlockByNumber` response
`signature`	string	`0x` + 130 hex (65 bytes); produced by `wallet.signMessage(blockHash)`
`signerAddress`	string	`0x` + 40 hex; address that produced the signature

Responses

Status	Body	When
201	`{ ok: true, blockNumber, attestor }`	Accepted, row inserted
200	`{ ok: true, duplicate: true }`	Same `(blockNumber, attestor)` already exists
400	`{ error: { code: "INVALID_BLOCK_NUMBER" } }`	bad / negative integer
400	`{ error: { code: "INVALID_BLOCK_HASH" } }`	not 0x + 64 hex
400	`{ error: { code: "INVALID_SIGNATURE" } }`	not 0x + 130 hex
400	`{ error: { code: "INVALID_SIGNER" } }`	not 0x + 40 hex
400	`{ error: { code: "BAD_SIGNATURE" } }`	recovery threw
400	`{ error: { code: "SIGNATURE_MISMATCH" } }`	recovered address ≠ `signerAddress`
400	`{ error: { code: "BLOCK_HASH_MISMATCH" } }`	hash claimed ≠ on-chain hash
400	`{ error: { code: "BLOCK_TOO_OLD" } }`	block is more than 200 behind head
404	`{ error: { code: "BLOCK_NOT_FOUND" } }`	block does not exist on-chain
500	`{ error: { code: "INSERT_FAILED" } }`	database write failed

There is no bond, stake, jail or registry check anywhere in this handler.

`GET /api/validator-attest/me/:address`

Endorsement counters for a single address.

{
  "address": "0x8be976d625e78076f3188f53f6f0c9d36cca2fef",
  "total": 7,
  "lastBlock": 6841,
  "lastAttestedAt": "2026-05-03T16:59:01.361Z"
}

`GET /api/validator-attest/recent?limit=50`

Most recent endorsements across all submitters (max 200).

{
  "items": [
    {
      "blockNumber": 6841,
      "blockHash": "0x...",
      "attestor": "0x...",
      "attestedAt": "2026-05-03T16:59:01.361Z"
    }
  ]
}

`GET /api/validator-attest/leaderboard`

Top 50 submitters by row count.

{
  "items": [
    { "attestor": "0x...", "total": 47, "lastBlock": 6841 }
  ]
}

`GET /api/validator-attest/stats`

Totals across the table.

{
  "total": 42,
  "uniqueAttestors": 6,
  "latestBlock": 6841
}

Client example (TypeScript + ethers v6)

import { ethers } from "ethers";

const RPC = "https://rpc.54-237-170-237.sslip.io";
const API = "https://api.54-237-170-237.sslip.io/api";

const provider = new ethers.JsonRpcProvider(
  RPC,
  { chainId: 7717, name: "youthchain" },
  { batchMaxCount: 1, staticNetwork: true }
);

let lastEndorsed = 0;

async function endorseNewBlocks(wallet: ethers.Wallet) {
  const blockNumber = await provider.getBlockNumber();
  if (blockNumber <= lastEndorsed) return;

  const block = await provider.getBlock(blockNumber, false);
  if (!block?.hash) return;

  const signature = await wallet.signMessage(block.hash);

  const r = await fetch(`${API}/validator-attest`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      blockNumber,
      blockHash: block.hash,
      signature,
      signerAddress: wallet.address.toLowerCase(),
    }),
  });

  if (r.ok) lastEndorsed = blockNumber;
}

setInterval(() => endorseNewBlocks(myWallet).catch(console.warn), 5000);

Notes

Sign the block hash string, e.g. wallet.signMessage(block.hash). signMessage applies the EIP-191 personal_sign prefix, and the server uses ethers.verifyMessage, which expects exactly that.
The hash must come from the canonical chain. A stale or reorged hash fails the server-side comparison against eth_getBlockByNumber.
Freshness gate: blocks more than 200 behind head are rejected, which limits bulk backfilling of old signatures — it does not make forged participation expensive, because there is no bond.
(blockNumber, attestor) is unique; re-submitting returns 200 with duplicate: true.
Do not derive validator counts, security claims or “N validators” figures from this table. The number that would mean something is bonded, slashable, sampled weight, which this endpoint does not measure.

API Reference

JSON-RPC (Ethereum-compatible)

Mobile REST API

Faucet