Policy for liquidity / Devnet reference

Every pool carries an edict.

The band bounds the pool. The edict writes the law. The chain enforces the verdict. A market where the rule is readable before you sign — and the trade cannot leave the rule.

Read the spec Open the policy lab
Band
≤ 22,528 ticks
Edict
8-byte verdict
Admin
None
MARK 01 THE SEAL
EDICT mark: a cream square seal around a gold core on an ink field.
Gold is the ruling. Cream is the boundary. Ink is the chain.
BAND / LIVE POSITION +1,842
−11,264 0 +11,264

01The gap

Liquidity became permissionless. Policy stayed private.

Anyone can open a pool. Almost no one can read its rules. The fee is a constant, the switch sits with a deployer, and the exception is handled off-chain. You sign first and learn the terms at settlement.

FEE One rate for every wallet. A rule that reads the wallet.
CONTROL A key that can change the terms. A program that cannot.
ENFORCEMENT A keeper with discretion. A verdict inside the instruction.
01Band

The jurisdiction.

A pool declares [tick_min, tick_max] at birth. The width is capped at 22,528 ticks. Outside the band there is no state, no quote, and no crossing.

02Edict

The written law.

One program per pool. Set at creation, immutable after. It is consulted before and after every swap and liquidity event. No oracle. No keeper.

03Verdict

The ruling.

Eight bytes: PASS, CHARGE, or REFUSE. The pool applies it atomically. If the edict refuses, the instruction does not exist.

“An edict cannot be bypassed.”
The core rule / 01

02The trade

Read the rule before you sign. Then keep what it charges.

A policy layer is only worth the change it makes in front of you. Here is the change, by role.

01Trader

The quote includes the verdict.

Call quote_edict before you build. You see PASS, the exact surcharge, or REFUSE. If it refuses, nothing fills. You are not repriced after signing.

0post-trade surprises
02Liquidity provider

The surcharge is yours.

Every basis point an edict charges stays in the pool and accrues to liquidity providers. The protocol takes zero. Pick a pool whose law you believe in.

100%surcharge → LPs
03Creator

Write once. Renounce nothing.

Attach an edict when the pool is created. There is no admin key to hand over and no switch to leave behind. The law is part of the market.

1edict per pool
04Builder

One CPI in.

Any program can consult an edict. No allowlist, no SDK required, no off-chain service in the path. Eight bytes come back.

1CPI to consult
Devnet readout Reference feed · not a live market
Pools with an edict 214
Verdicts / 24h 96,480
Charged volume / 24h $4.18M
Median surcharge 21 bps
Refused 0.61%
Surcharge to LPs / 30d $74,120
Verdict mix / 24h96,480 rulings
Pass 78.39% Charge 21.00% Refuse 0.61%

Most trades pass. The ones that charge pay LPs, not a treasury. Refusals are the guardrail, not the business model.

BlockIntentEdictVerdict
284,119 2.4 SOL buy BREATH CHARGE 38 bps
284,118 0.8 SOL sell GUARD PASS
284,117 12.0 SOL buy GUARD REFUSE · 612 bps
284,116 1.1 SOL sell FLAT CHARGE 15 bps
284,115 5.0 SOL buy OPEN PASS

Seeded reference feed for the devnet build. No wallet, no chain call.

03The ruling

A swap is a question. The edict answers.

Four beats. The pool never moves a reserve before the law has been read.

  1. 01

    Quote

    Free, off-chain, exact.

    quote_edict(pool, intent) returns the same bytes the chain will compute. No signature, no fee, no state change.

  2. 02

    Cross

    The intent enters.

    The pool assembles pre-state, the swap, and the accounts the edict declares. It calls the edict before any reserve moves.

  3. 03

    Rule

    Deterministic. Bounded.

    The edict runs inside a fixed compute budget. It can read accounts. It cannot read an oracle, call out, or write state.

  4. 04

    Settle

    Apply or revert.

    The pool applies PASS or CHARGE atomically. REFUSE reverts the whole instruction. Nothing is partially ruled.

Simulated trace / devnet 
$ edict quote --pool 7xKX…q9 --side buy --amount 2.4
  verdict   CHARGE
  fee       38 bps
  ttl       8 slots
  lps       +0.00912 SOL
$ edict settle --block 284,119
  applied   block 284,119 · slot 348,771,204
  quote     equal to settlement
$ edict quote --pool 7xKX…q9 --side buy --amount 12.0
  verdict   REFUSE
  reason    GUARD / impact 612 bps > 250 bps cap
  state     unchanged
$ edict settle --block 284,120
  reverted  whole instruction · no reserves moved
  quote     equal to settlement
Quote = settlement Same function · same bytes

04The laws

Five laws out of the box. Or write your own.

A stock edict is a small program with parameters. It reads the pool, the intent, and the accounts it declares — nothing else.

00Stock

Open

No surcharge. No exception.

A band and nothing else. The simplest way to put a pool on the record.

fee = 0
01Stock

Flat

One rate, written once.

A fixed surcharge in basis points. It cannot be raised, lowered, or switched off after creation.

fee = 15 bps
02Stock

Breath

A fee that reads the market.

Surcharge expands with five-minute realized volatility and decays every slot. No oracle; the pool's own prints are the input.

min(cap, base + k · vol)
03Stock

Guard

A ceiling on damage.

Refuses a swap that would move price beyond the impact cap, or a second swap from the same wallet in the same slot.

impact ≤ 250 bps
cooldown = 1 slot
04Stock

Quote

Fill only what was quoted.

Requires a signed quote from a declared quoter. The pool fills at the quoted terms or not at all. Expires in eight slots.

ttl = 8 slots
Build your own

Any program can be an edict. Implement one instruction, return eight deterministic bytes, declare the accounts you read. That is the whole interface.

See the interface

05The band

The band is not a chart. It is the coordinate system.

Prices are integers. A tick is one basis point in log space. A pool declares its edges at birth and lives inside them.

22,528 Max band width / ticks
Ticktick(p) = ⌊ ln(p) / ln(1.0001) ⌋
Bandband = [t_min, t_max] · width ≤ 22,528
Fillfill = min(intent, depth_to_edge)
Outsideoutside(t) = ∅
Tick precision
1 bp
Max width
22,528 ticks
State outside
None
Oracle reads
None
Admin overrides
None

06The lab

Set a law. Watch it breathe.

BREATH turns realized volatility into a surcharge. Drag the market and read the exact verdict a trader would get. This is a model, not a promise.

bps per five minutes

bps, charged even in a quiet market

bps, enforced by the pool

Formula fee = min(cap, base + 1.4 × vol) Integer math on-chain. Rounded down.
Verdict / 2.0 SOL buy CHARGE 43 bps
8 bytes 01 2B 00 08 00 00 00 00
Surcharge / volatility 43 bps @ 24
LP share / 2 SOL0.0086 SOL
Headroom to cap77 bps
Verdict tagCHARGE

Model only. The on-chain BREATH edict uses integer basis points and rounds down; the curve above is illustrative.

07The integration

One instruction in. Eight bytes out.

The interface is deliberately small. The edict is a read-only program; the pool is the only thing that can apply a verdict.

Interface
check(pool, intent, accounts) → [u8; 8]
Compute
200,000 CU cap
State
Read-only
CPI out
Forbidden
Determinism
Required
Upgrade
Never, after pool creation
Protocol fee
0 bps

A custom edict can read any account the pool passes it. It still cannot make an external call, write state, or return a different answer twice.

Read the full spec Follow @edictztd 
use edict_core::{check, Intent, Verdict};

let verdict = check(
    &pool,
    Intent::Swap { side, amount_in },
    ctx.remaining_accounts,
)?;

match verdict {
    Verdict::Pass => pool.swap(amount_in),
    Verdict::Charge { bps } => pool.swap_with_fee(amount_in, bps),
    Verdict::Refuse => return Err(EdictError::Refused.into()),
}
import { quoteEdict } from "@edict/sdk";

const v = await quoteEdict({
  pool: "7xKX…q9",
  side: "buy",
  amountIn: 2_400_000_000n,
});

// { tag: 1, feeBps: 38, ttlSlots: 8 }
if (v.tag === 2) return; // REFUSE
sendSwap({ ...swap, feeBps: v.feeBps });
Spec v0.1 · devnet No admin · no protocol cut

08The boundaries

What it refuses to do is part of the design.

A policy layer is defined by the powers it does not have.

No admin key No global fee switch No off-chain keeper No oracle required No protocol cut No post-signature repricing

The first pool

$EDICT

The first market to carry an edict. The token has no special rights over the protocol: no fee switch, no admin, no claim on surcharges. A market, not a master key.

Contract

No presale. Verify the contract address before trading.

@edictztd pump.fun

It is a policy layer that runs with a pool. The pool trades; the edict sets the terms. The same law can sit in front of any pool that implements the interface.

The pool creator, at creation. It cannot be swapped later. To change the law, open a new pool.

It stays in the pool and accrues to LPs. The protocol takes 0 bps. There is no treasury cut.

Not by default. Stock edicts read the pool's own state. A custom edict can read any account the pool passes it, but it still cannot make an external call.

Then that pool's law is buggy. The blast radius is one pool, and the band still bounds the damage. This is why edicts are small, deterministic, and immutable.

The token contract is live on pump.fun. The protocol itself remains a devnet reference build: the numbers on this page are a seeded feed, and nothing here is a promise of returns.

The first pool to carry an edict. The token has no special powers: no fee switch, no admin, no claim on surcharges. It is a market, not a master key.

At the top of this page, in the token card, and in the footer. Copy it from the contract rail and verify the address before trading.

09The invitation

Write the law once. Build on one primitive.

Every pool carries an edict. Including this one.

Follow @edictztd Read the spec
EDICT / MARK 01 / THE SEAL