WEAVER
Build with WEAVER>

Developers

WEAVER is modular by design. Integrate only what your application needs — intelligence, evidence, or on-chain threat state — and nothing here is presented as live before it is.

01Building blocks

Four pieces, each with an honest status

Live · read-only

Ingestion adapter

Reads only what Crawlnet's public API exposes — crawl feed, dataset chapters, spiders, Queen — and keeps source URL, timestamps and provenance on every record.

Live · link graph

Evidence graph

THREAD builds its graph from the real link structure of pages Crawlnet read. Queen answers sit next to sources, labelled as AI output.

Testnet

WARD contracts

Quorum-signed threat-state registry plus an example guarded vault, with EIP-712 signatures, sequencing and replay protection. Not audited.

Planned

SDK

A thin client for reading WARD state and subscribing to updates from an application backend. Not built yet — read the contract directly for now.

02Integrate WARD

Read the state, choose your failure mode

WARD never calls your contract. You read it, and you decide up front what happens when it is stale or paused.
Solidity · on-chain policy
import {IWeaverWard} from "weaver/interfaces/IWeaverWard.sol";

contract GuardedVault {
    IWeaverWard public immutable ward;
    bool public immutable failClosed;

    function _checkPolicy(uint256 amount) internal view {
        IWeaverWard.ThreatLevel level;
        // reverts when WARD is stale or paused
        try ward.currentLevelOrRevert() returns (IWeaverWard.ThreatLevel l) {
            level = l;
        } catch {
            if (failClosed) revert WardUnavailable();
            return; // fail-open: your choice, made explicitly
        }
        if (level >= IWeaverWard.ThreatLevel.Verified) revert Blocked(level);
    }
}
TypeScript · off-chain read (viem)
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  chain: robinhoodTestnet,
  transport: http(),
});
const ward = {
  address: WARD_ADDRESS,
  abi: weaverWardAbi,
} as const;

const state = await client.readContract({
  ...ward,
  functionName: "getThreatState",
});
const stale = await client.readContract({
  ...ward,
  functionName: "isStale",
});
// level: 0 Baseline · 1 Elevated
//        2 Verified · 3 Actionable

Condensed from contracts/src/examples/ExampleGuardedVault.sol.Contracts on this deployment are testnet prototypes — do not guard real funds with them.

03Guard builder

Generate a contract that respects WARD

Pick the functions to guard and the level that stops them. You get a Solidity starter that inherits WeaverGuarded, written in your browser. Nothing is deployed.

Guarded functions

  • Refuse from
  • Refuse from

Starter template generated in your browser. It is not audited — review, test and get it audited before it holds funds. WARD is a signal your contract reads; it never calls your contract.

MyVault.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

// Starter generated by the WEAVER Guard builder. NOT audited: review, test
// and audit before use. Copy WeaverGuarded.sol and interfaces/IWeaverWard.sol
// from the WEAVER repo (contracts/src) into your project and remap
// "weaver/" to that folder.
import {IWeaverWard} from "weaver/interfaces/IWeaverWard.sol";
import {WeaverGuarded} from "weaver/WeaverGuarded.sol";


// payable: this starter has no way to move ETH out. Add a guarded withdraw,
// or ETH sent here is locked forever.
/// WARD on Robinhood Chain Testnet (chain 46630): 0x594b565C602D22cC2efb2f0cC9D67AF1556154D4
contract MyVault is WeaverGuarded {
    constructor(IWeaverWard ward_) WeaverGuarded(ward_) {}

    /// Reverts from Verified up, and whenever WARD is stale or paused.
    function withdraw(uint256 amount) external quantumGuarded(IWeaverWard.ThreatLevel.Verified) {
        // your logic
    }

    /// Reverts from Actionable up, and whenever WARD is stale or paused.
    function deposit() external payable quantumGuarded(IWeaverWard.ThreatLevel.Actionable) {
        // your logic
    }
}

04Deployments · Robinhood Chain Testnet

Contract addresses

Read from this deployment's configuration. An empty row means the address is not set — nothing is filled in for show.

WeaverWard

Threat-state registry

0x594b565C…6154D4

MendRegistry

Recovery readiness

0x15e58454…F991bd

ExampleGuardedVault

Reference integrator

0x9D2cb09d…D4Eb62

05Environment template · no secrets

Configure your own deployment

Addresses are public. RPC URLs stay server-side, and signer keys never touch the web app.
.env.example
# public — addresses only
NEXT_PUBLIC_WEAVER_NETWORK=testnet
NEXT_PUBLIC_WARD_ADDRESS=
NEXT_PUBLIC_MEND_ADDRESS=
NEXT_PUBLIC_EXAMPLE_VAULT_ADDRESS=

# server-only — never NEXT_PUBLIC_*, never committed
RH_TESTNET_RPC=
RH_TESTNET_LOGS_RPC=
WARD_DEPLOY_BLOCK=
CRAWLNET_API_BASE=https://api.crawlnet.network/v1

06Project status

Where WEAVER actually is

Phase
3 — Testnet prototype
Crawlnet integration
Live · public API, read-only
Contracts
Deployed · Robinhood Chain Testnet
Contract audit
Not started
Mainnet deployment
Not deployed

No production security claim is made until the relevant implementation has passed review and testing. See the documentation for phase deliverables and exit criteria.