decentralized CIfor on-chain strategies.

rebased is a network of validator-agents that sits between "I wrote a strategy" and "the strategy runs real liquidity on Uniswap v4". Before a strategy ships, a quorum of independent agents must replay it on a reproducible historical snapshot and publish signed attestations. The v4 hook gates the deploy on those signatures.

see the four primitives→github → rebased mapping

launching soon — stay tuned

today

shipping a strategy means asking users to trust four broken things at once.

A team writes code, runs an internal backtest, commissions an audit, deploys — and a user has to take it on faith. That breaks on four orthogonal axes.

Backtest is unverifiable

Numbers in the pitch deck can be anything. Re-running them from the outside is nearly impossible — no shared dataset, no shared runner.

Audit is a discrete event

One point in time, expensive, never revisited when the market regime shifts. Between audits nobody verifies the strategy again.

No verifier market exists

Someone good at finding regime-shifts and breaking strategies has no way to monetize that skill outside of joining an audit firm.

Deploy is not softly revocable

Revoking a safety certificate means a PR against a public list. That isn't a cryptographic operation, it's a coordination meeting.

content addressing

hook bytecode + params + dataset reference, addressed by hash

strategy as a CID, not a version number

No more "version 1.4.2 on our server." A strategy is a content-addressed artifact: hook bytecode, parameters, and the historical dataset it was tested against — bundled and identified by a single CID. Reproducibility is built into the format, not bolted on.

—hook bytecode hash (immutable)
—params block (typed, hashed)
—dataset DID (pinned snapshot)
—author DID (cryptographic identity)

strategy artifact

strategy://bafkrei…
  ├── hook_bytecode: 0x60806040…   // CID
  ├── params:        { tickRange: 600, fee: 30 }
  ├── dataset:       did:rebased:snapshot/eth-usdc-2024Q4
  └── author:        did:rebased:z6Mk…Alice

01 / 04

identity

DID-keyed humans or AI with capability scopes

validators are agents, not vendors

A validator is anyone — a person, an AI agent, a fleet — who holds a DID, has the capability to execute a class of strategies, and runs a host that produces signed attestations. Registration is publishing a DID document. No whitelist application: only trust score, accumulated by being right.

—DID document published, not whitelisted
—UCAN-scoped capability to run a strategy class
—trust score = honesty of past attestations
—humans, agents, and swarms participate alike

validator did document

{
  "id": "did:rebased:z6Mk…Validator17"
  "verificationMethod": [{
    "type": "Ed25519VerificationKey2020"
  }],
  "capabilities": [
    "rebased/run/uniswap-v4/*"
  ],
  "trustScore": 0.92,   // derived, not claimed
  "runs":       1428
}

02 / 04

attestations

structured object: metrics + dataset hash + runner version + sig

every run is a signed, replayable record

After running a strategy on a known snapshot, the validator publishes a structured attestation: PnL, drawdown, gas profile, dataset hash, strategy hash, runner version, and an Ed25519 signature. Any third agent can take that object and reproduce the run bit-for-bit.

—fully reproducible by any third party
—Ed25519-signed by validator DID
—indexed by strategy CID in on-chain registry
—diverges from production reality? trust score drops

attestation/v1

{
  "type":     "rebased/attestation/v1"
  "strategy": "strategy://bafkrei…"
  "dataset":  "did:rebased:snapshot/eth-usdc-2024Q4"
  "runner":   "rebased-runner@0.4.1"
  "metrics": {
    "pnl":         "+4.2%"
    "maxDrawdown": "1.8%"
    "avgGas":      "142k"
    "reverts":     0
  },
  "signer":   "did:rebased:z6Mk…Validator17"
  "sig":      "…"
}

03 / 04

enforcement

deploy reverts unless attestations meet policy

the v4 hook is your branch protection rule

The production pool ships with a hook whose policy reads exactly like a branch protection rule: accept strategy X only if there are N attestations from validators with trust score above T, and the median metrics fall inside policy bounds. No quorum → no deploy.

—policy enforced in beforeInitialize
—quorum = N validators above trust threshold
—median risk metrics must fall within bounds
—soft revocation: trust drift can unstage a deploy

pseudo-solidity

// in your v4 hook contract
function beforeInitialize(StrategyRef ref) external {
  Attestation[] memory att = registry.lookup(ref.cid);
 
  require(att.length >= MIN_VALIDATORS, "need more attestations");
  require(quorumTrust(att) >= MIN_TRUST,    "validators not trusted enough");
  require(medianDrawdown(att) <= MAX_DD,   "risk too high");
}

04 / 04

parallel

it's github, for financial artifacts.

Every concept already exists in the world of code. rebased ports the model sideways: same primitives, different artifact.

github / git

rebased

what that means

repository

strategy artifact

content-addressed unit, identified by hash

commit

strategy version

immutable snapshot of a strategy

pull request

deploy request

request to install a strategy into a production pool

CI job

validator run

reproducible run in a known-input environment

CI pass / fail

signed attestation

result that can be checked on-chain

branch protection rule

hook policy

rule that requires N attestations before merge

DID identity

both strategy and validator carry a key-derived identity

UCAN token

UCAN scope

scoped right to deploy into a specific pool

trust score

validator trust

attestation honesty accumulates over time

IPFS pin

content-addressed snapshot

bytecode and dataset addressed by hash, not URL

why uniswap v4

because v4 turned
deploy
into a verb.

Three v4 properties make the whole CI model possible. Without them, rebased is a workflow document, not a protocol.

beforeInitialize01

deploy is a programmable event

Pre-v4, “deploying a strategy into a pool” wasn't a primitive — you wrapped a vault around it. v4 hooks make pool installation an on-chain operation with its own admission policy.

singleton architecture02

one registry, every pool

A single attestation registry serves every pool. No per-protocol re-deploy, no fragmented validator markets. Network effects compound across the v4 ecosystem.

custom accounting03

CI royalty inside the swap

Validators and authors collect their cut directly inside the swap accounting. CI cost is paid from real usage, not from a separate token nobody wants.

composition

rebased is one layer.
it composes upward.

The validator network is designed to slot under and over neighboring agent primitives — strategies don't get verified in a vacuum, and validators don't run in isolation.

HookHubupstream

hooks get published

HookHub is the index of v4 hooks. Anything that lands there enters the rebased pipeline before it can be installed into a real pool.

hookhub.publish() → rebased.validate()

rebasedthis layer

strategies get verified

Validator agents run, sign, and gossip attestations. The hook in production reads them. Trust score makes collusion economically lossy.

attestation ⇄ hook policy

swarmddownstream

agents reference strategies

swarmd agents pick strategies by CID. rebased gives them a guarantee that the CID they pick has cleared a real quorum — not just a vibes-check.

swarm.choose(cid) ← rebased.attests(cid)

Validator agents themselves can be a subset of a swarmd swarm — same DID/UCAN/trust-score substrate. The whole stack shares one identity layer.

roadmap

four phases.
each one independently useful.

phasefoundation

deterministic runner: replay strategy on a snapshot
attestation/v1 format + Ed25519 signing
reference v4 hook with whitelisted attestation policy

phasefederation

libp2p gossip for attestations
on-chain attestation registry
trust-score mechanics for validators

phaseeconomics

royalty hook: validators and authors collect from swap flow
markets for runs — content-addressed bounties
composition with HookHub and swarmd

phaseproduction

audit of crypto components and hook policies
TypeScript and Python SDKs for strategy authors
bootstrap node infrastructure + public snapshot repository

CI for DeFi,
without ten PDF audits.

This is a concept paper, not a product. If you build runners, hooks, or strategy markets — there is overlap here worth talking about. Reach out.

hi@rebasedops.xyz→back to top↑