Touchstone

Your manager pays for their own bad trades.

A Uniswap v4 vault that checks every manager action against a deep market's price, and charges any shortfall to the manager's held-back pay.

You hand your money to a manager you cannot watch, and you pay them anyway. When a liquidity vault's manager moves your money, every trade has a cost: fees, a bad price, or a friend on the other side who profits. Today that cost comes out of your balance, and the manager's pay does not change.

Touchstone flips it. Every time the manager acts, the vault checks the result against the price on a much larger market. Any shortfall is taken from the manager's held-back pay and then from a bond the manager posted up front. If the manager cannot cover it, the action does not happen. Market moves are still yours.

Think of a broker whose every order is compared with the exchange's price, with any gap deducted from the broker's held-back bonus.

Live · — · block — spot — · reference — · gap —

The manager's books example amounts

    One sample is 10 minutes of real prices; the manager's actions are scripted.

    A simplified model of the rules running in your browser on real USDC/ETH prices. Example amounts for a 1,000 ETH vault; measured results are below.

    Prices: Uniswap v3 USDC/WETH 0.05% on Ethereum mainnet (0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640), blocks 26,357,020 to 26,443,420, one sample every 50 blocks. Spot is that pool's price at each sampled block (slot0). The reference is the same pool's own 10-minute TWAP at that block (observe([600, 0])), not an average of the samples. In the real design spot is the vault's own pool, kept close by arbitrage. Example amounts use the mainnet ratios of script/Tiers.sol: bond 0.174% (1.74 ETH per 1,000), reserve 0.06% (0.6 ETH), deferred pay about 1.7–2.1 ETH (4 to 5 weeks of a 2.2% yearly fee; our arithmetic). In the model a charge is a small fixed cost plus a cost for the gap between spot and the reference; on chain the contracts measure it.

    Shown on a live test network

    Three promises. Three real transactions.

    We deployed the vault on a public test network and ran a manager against it. Each card is one promise the rules make to depositors, shown once on chain. The amounts are tiny because the price gaps in this run were tiny and the test market is our own small pool. Realistic costs are under Evidence (E8). This test vault has no outside depositors: its seed is the manager's bond. Each transaction shows who is billed (held-back pay and bond shares burned), not a depositor's gain.

    Live · Unichain Sepolia (test network) · 2026-11-20demo settings · test tokens
    Promise 1 · a routine move Billed to the manager

    What happened. The manager moved the vault's money to a new price range. The vault measured what the move cost against the deep market's price.

    Who paid. The manager (held-back pay first, then bond). Two minutes later a second check billed it more (about 2e-7 of the vault).

    Why it matters. Everyday moves are not free for the manager. The bill was not taken from the vault's other shares.

    Size: under one ten-billionth of the vault (≈ 8e-11), plus 2e-7 at the second check.
    Technical detailsetPositions · charged 335,126,463 wei = 3.35e-10 mock WETH of a ≈ 4 mock WETH vault · settlement burned 867,995,129,170 wei more (8.7e-7 mock WETH)
    the move 0xbad3…819a the second check 0x8f37…6582
    Promise 2 · a move at a pushed price Blocked

    What happened. Our script pushed this pool's price 0.9% (90 ticks) away from the deep market. Then the manager tried to move the money.

    Who paid. No one. The fence allows 0.6% (60 ticks). The transaction failed. Nothing moved, nothing was billed.

    Why it matters. A manager cannot trade your money at a price a friend has pushed.

    Size: the whole move was refused.
    Technical detailsetPositions · status 0 · reverted Fence() 0xe78b0e36
    the refused move 0x0057…956c
    Promise 3 · the manager's own trade Billed, from the bond

    What happened. The manager swapped some of the vault's tokens to rebalance it. The vault measured the cost.

    Who paid. The manager. Its held-back pay went first, then its bond (the deposit it posted up front): most of it from the bond, as its on-chain event shows. Only the manager's held-back pay and bond shares were burned.

    Why it matters. The bond is real money at risk. When held-back pay runs short, the bond pays.

    Size: about three millionths of the vault (≈ 3e-6).
    Technical detailrebalanceSwap · charged 11,534,237,164,438 wei = 1.15e-5 mock WETH of a ≈ 4 mock WETH vault · who paid: decoded from the vault's Action event (burnedBank, burnedBond)
    the swap 0x8e84…4e7e the second check 0x5d40…a889
    Test tokens. The "deep market" here is our own small test pool, so this run shows the rules working, not their strength. Their strength against a real deep market is measured on an Ethereum mainnet copy (Evidence, E8). Price path: the demo followed nine hourly mainnet price moves (USDC/WETH 0.05%, blocks 26,387,320 to 26,389,720), compressed to 30 s each, on mock-token pools. 26 scripted steps were sent. A first attempt stopped after 13 transactions on an RPC nonce error; this run is the second. source: script/demo/deployments-1301.json · driver script/demo/demoflow.sh · vault size: DeployDemo.s.sol seed

    How it works

    Checked against a price that is costly to fake.

    A pool on Uniswap is a shared pot of two tokens. Its spot price is cheap to push for a moment. So Touchstone never trusts it alone.

    Each vault is tied, for life, to a reference price: the 10-minute average of a much deeper pool. The manager may act only inside a narrow fence around it.

    When the manager acts, the vault values itself before and after, at both prices. The worse result is the execution cost. It is charged in full, from held-back pay first, then the bond. Two minutes later a markout checks the action again.

    The manager earns a base fee only for money placed in its range (measured in ticks). That pay is held back for weeks and vests only while the deep market's price is in range. Stay away too long and it is a breach.

    How costly? Holding the deep USDC/WETH pool's price 60 ticks off for one block costs about 1.04 WETH, measured on a mainnet copy (E8). The design assumes that reference is not moved; a single block builder controlling the whole two-minute window is outside it (Limits).

    Why two prices? The vault's own pool can be pushed cheaply, so pay and penalties follow the deep market's price. If only the vault's pool leaves the range, the fee pauses. If the deep market's price leaves it, vesting stops at once, and the fee and the 24-hour clock follow at the next hourly check.

    The numbers are the mainnet tier's (script/Tiers.sol). The testnet deployment runs the same rules faster (parameters under Builders).

     the manager wants to act
        │
        ▼
     spot within 60 ticks of the deep price?
        │ no ──▶ refused. nothing moves.
        │ yes
        ▼
     value the vault before and after,
     at the worse of the two prices
        │
        ▼
     a shortfall?
        │ none ──▶ done. no charge.
        │ some
        ▼
     pay + bond cover it plus a reserve?
        │ no ──▶ refused. nothing moves.
        │ yes
        ▼
     burn the manager's held-back pay,
     then its bond
        │ ──▶ every other share is worth a bit more
        ▼ 120 s later, anyone can trigger
     check again at the deep market's later
     price; take up to the reserve more

    Who is involved

    Four parties. What each wants, and what the rules do.

    Depositor

    Wants

    Its share of the vault, no unmeasured execution costs taken from it, and a way out.

    The rules

    Withdraw in kind at any time, in every mode. A deposit followed by a withdrawal never profits. Deposits are refused for about two minutes until a pending check settles.

    Why

    So no rule, charge or removal can lock depositors in, and no one can time a deposit around a charge.

    Manager

    Wants

    Steady pay for keeping money working.

    The rules

    Paid only for money placed in range. Pays every measured shortfall. Loses held-back pay if absent.

    Why

    To make doing the job pay. In our simulations, with no outside party refreshing the reference price, it paid better than every gated lazy or lax strategy we tested (U-IC2). With one, two lax strategies came out ahead at 120% volatility.

    Arbitrageur

    Wants

    Profit from any price gap. (A trader who pulls an off-price pool back to the market.)

    The rules

    Trades freely and is never charged. A gap the manager creates becomes its profit, and the manager's charge.

    Why

    So a manager colluding with a trader pays the trader's gain itself.

    Anyone who pokes

    Wants

    A correct record, for example to trigger a breach or settle a charge.

    The rules

    Can call settle, poke, process a breach and refresh the reference. Cannot move funds.

    Why

    So the vault needs no keeper, operator, admin or off-chain feed.

    How the incentives line up. Every bit of cost the manager avoids is pay it keeps; gains never earn extra. Sloppy or self-dealing trades come out of its own pay and bond. Idling earns nothing. Walking away costs everything held back. In our simulations, with no outside party refreshing the reference price, doing the job paid better than every gated lazy or lax strategy we tested (U-IC2). With one, two lax strategies came out ahead at 120% volatility.

    Why a manager signs up. A record of its execution, kept by the pool, that anyone can check. A published term sheet. A fee for capital it keeps working.

    Five scenes

    Move the price. Watch the books.

    Each scene runs the same simplified model as the stage above, with example amounts for a 1,000 ETH vault. Drag the timeline, change the controls, and read the measured result under the stage.

    —

      —spot — · reference — · gap —

      The books example amounts

        Example amounts for a 1,000 ETH vault, in a simplified model running in your browser. The measured result is named below.

        Pay

        How a manager earns, and how it loses.

         money placed in range, spot and reference inside
            │
            ▼
         base fee: 2.2% a year × the share placed
            │
            ▼
         held back 4-5 weeks ──▶ vests, if the deep
            │            market's price is in range
            │
            ├──▶ bad execution
            │      charged from held-back pay, then bond
            │
            ├──▶ the deep market's price leaves the range
            │      vesting stops; fee, clock follow hourly
            │      24 h out = a breach (strike):
            │      held-back pay burned for every share
            │      3 breaches = removed
            │
            └──▶ the manager walks away
                   its held-back pay is forfeited
                   at the first breach

        The deal

        Is 2.2% a good deal? Only if the manager does the job.

        The manager earns 2.2% a year on money it keeps working. It risks a small bond and pays its own bad trades. Pick a market and compare what each kind of manager takes home.

        Manager's net take-home in ETH over 180 days, for a 1,000 ETH vault: after charges and gas, from 400 simulated price paths per market, no third-party liquidity, gas at 5 gwei (U-IC2, no outside party refreshing the reference price). "Most it can earn" is the ceiling at a constant 1,000 ETH, fully in range: 2.2% a year × 1,000 ETH × 180 of 365 days (our arithmetic).

        Capital the manager risks1.74 ETHits bond, 0.174% of the vault
        Bond lost on average, 180 days—doing the job (U-IC2-agg)
        Its own bad trades, billed to it—of the vault a year, simulated (E8)

        For the manager

        A good deal when it does the job: re-places the range when the market moves, and keeps the money working. Lazy or idle strategies take home less. The margin is thinnest in wild markets. The 2.2% rate is fixed in the code and was not tuned after seeing the data; the 12-hour wait behind these bars was chosen after an earlier test failed (Limits).

        For depositors

        You pay 2.2% a year only on money that is placed and working, and only while both prices are in the range. Idle money costs nothing. Execution costs the vault measures are billed to the manager. Whether the trading fees your money earns beat 2.2% depends on trading volume, which these simulations do not include; we publish no break-even.

        The vault's value is a separate question. In the same simulations, the vault ended with more value under the lax strategies than under the manager that does the job (at 120%: about 558 and 569 against 314, from 1,000), because with no other traders in the model, time in range is mostly loss to arbitrage. Market moves stay with depositors (Limits).

        With an outside party refreshing the reference price, two lax strategies came out ahead at 120% volatility (Limits).

        Evidence

        Built to be trusted. We tried to break it, and wrote down how.

        467 tests, 0 failing

        Including 73 attack tests and 11 run on Ethereum mainnet state at block 26,443,420. audits/test-summary.json

        328 of 328 planted bugs caught

        332 planted bugs, each tied to a rule and the test that must catch it; 328 of 328 caught, 4 equivalent. audits/mutants.json

        Attacks lose money, with controls

        Every asserted attack row in 17 attack cells nets ≤ 0. In 14 cells a separate control removes the defence and the same attack profits, so the test can fail. Self-sandwich worst row −0.0030, control +0.0155 (token units, test vault). README, E5

        Invariant campaigns

        Random sequences of swaps, placements, settlements and vesting check the vault's core rules: 64 × 64 in every test run, 256 × 128 in the local CI campaign, then a check that the campaign really exercised each action.

        A second implementation

        A Python model written from the specification, not from the contracts, produces test vectors the contracts match bit for bit. model/reference.py

        Claims tied to tests

        A script fails the build when a claim has no test or result: 104 of 106 current claims covered. The two open ones (E5, E-IC) are in Results and Limits.

        Registered before the data

        Questions, pass rules and seeds were committed before each run; passes and failures are both published. The charge covers an honest placement's realised loss on all sampled exit states (E2). It is exactly 0 wei without a manager action over 10,000 segments and 20,034 third-party swaps, in the independent model (E3). The reference manager out-earns every gated strategy on 400 fresh simulated paths per bucket, binding case +0.235 ETH with a 95% lower bound of +0.166 ETH, with no outside party refreshing the reference price (synthetic paths, no third-party liquidity) (U-IC2).

        Measured on a mainnet fork and locally

        Holding the deep USDC/WETH pool's price 60 ticks off for one block costs 1.04 WETH, on a mainnet fork (E8). Largest contract 19,877 bytes of a 22,000 budget; the first swap per block costs 26.7k gas (E7).

        Live on testnet

        Deployed on Unichain Sepolia on 2026-11-20 and driven by 26 scripted steps, following nine hourly mainnet price moves, compressed to 30 s each, on mock-token pools: one charged placement, one fence refusal, one charged swap. script/demo/deployments-1301.json

        Reviewed adversarially

        Fund-touching designs were reviewed adversarially before implementation (internal process).

        Mutation testing curated

        328 killed

        We changed one rule at a time in our own code. Each change names the test that must catch it. 328 of 328 wired mutants were caught, in one campaign (four slices) at one commit.

        listed
        332
        wired (in the denominator)
        328
        killed by the named test
        328
        equivalent (no input can tell them apart), listed apart
        4
        listed, by area: guards
        87
        ledger (the charge)
        78
        ladder (breaches, vesting)
        33
        bank (pay, bond, forfeits)
        19
        records
        15
        witness
        8
        other areas
        92
        python3 script/mutate.py --audit
        python3 script/mutate.py -j 1 MU-001 …
        source: audits/mutants.json (status per mutant) · script/mutate.py

        Invariants stateful fuzzing

        13 invariants

        Each runs in two pool states, a 1:1 pool at tick 0 and a USDC/WETH-like pool near tick 196,000: 26 invariant runs in the suite.

        A handler makes random calls: deposits, withdrawals, swaps, placements, settlements, pokes. After each call the invariants are checked.

        in forge test
        64 runs × 64 calls
        in the CI script
        256 runs × 128 calls
        non-vacuity floor: real mint-and-vest events
        ≥ 1,000
        non-vacuity floor: mint-and-vest calls
        ≥ 600

        The non-vacuity check fails the campaign if it executed too few swaps, placements, moves, settlements or vests.

        CLAIMS_PHASE=P6 script/ci-local.sh
        source: test/invariant/VaultP2.t.sol · script/nonvacuity.py

        Static analysis Slither 0.11.5

        215 triaged

        Every Slither result on src/ has a verdict: false positive, by design, or accepted. None needs a code change.

        High
        10
        Medium
        81
        Low
        27
        Informational and optimisation
        97
        contracts analysed · detectors
        64 · 101
        static tests (record pinned to src)
        13 passed
        source: audits/SLITHER.md · audits/slither-results.json · test/static/test_static.py (S-1)

        Foundry suite FORK_BLOCK_1=26443420

        467 passed

        0 failed. 0 skipped. Fork tests run against mainnet at a pinned block.

        unit
        301
        manipulation
        73
        invariant
        44
        fuzz
        12
        fork
        11
        deploy
        17
        eval
        9
        by kind: fuzz
        33
        invariant
        26
        plain
        408

        Every asserted attack row loses money. Each control test asserts that the attack profits with the defence removed. 14 of the 17 attack cells have one (see E5).

        source: audits/test-summary.json (script/test_summary.py)

        Independent reference model Python

        Bit for bit

        A model written from the specification, not from the Solidity. Its golden vectors are matched bit for bit by the contracts. Its self-check must pass.

        python3 model/reference.py --selfcheck
        source: model/reference.py · test/vectors/

        Size and gas

        19,877 B

        The largest runtime, against a 22,000 B gate (EIP-170 is 24,576).

        TouchstoneVault
        19,877 B
        TouchstoneVaultExtension
        15,046 B
        TouchstoneHook
        14,329 B
        TouchstoneFactory
        6,416 B
        forge build --sizes src
        source: eval/results/E7.json · audits/size-budget.json

        Results

        Pre-registered. Published whichever way.

        Each row has its result file. Badges come from each file's verdict field.

        IDQuestionVerdictResult
        E1Is the witness a real position?PASS0 wei difference, exact equality on 256 fuzz runs.
        E2Does the charge cover an honest placement's realised loss?PASSCovered on 2,016 and 2,100 sampled exit states (σ 60 and 120%). Mean overcharge 0.012 and 0.023 bp of NAV. Synthetic.
        E3Is the charge zero without a curator action?PASS0 wei over 10,000 segments and 20,034 third-party swaps. Control: one swap is charged. Independent model.
        E4Does the reference curator out-earn idle, dust, stale and wide curators?PASSIn every bucket. Idle nets exactly 0 before gas. Synthetic.
        E5Do the asserted attacks lose money?FAIL (control form)FAIL (control form) under the registered rule. Every asserted attack row in all 17 cells nets ≤ 0; 14 cells have a control test that profits with the defence removed; N1 and N2 have inline sensitivity checks; N3 is a forgery cell. Under the rule as amended after the data: PASS.
        E6Does churning pay?PASSChurner minus reference curator: t = −129 to −691 per bucket. Synthetic.
        E7Gas and size within budget?PASSLargest runtime 19,877 B (limit 22,000). First swap per block 26.7k gas. Worst action 871k (budget 1.2M).
        E8Operating numbersREPORTED11 items reported, 6 not run. Reference curator charged 1.6, 4.0 and 15.7 bps of NAV a year at 40, 60 and 120% volatility.
        E9Why is positioning not paid?REPORTEDA carry benchmark pays a random curator +40%, +6% and −13% above base across three regimes.
        U-IC2Does the reference curator out-earn lazy and lax ones?PASSOn 400 synthetic paths per bucket, no outside observer. Caveats under Limits.
        E-ICIncentives on a historical price pathNOT RUNU-IC2 covers its comparison on synthetic paths only. Supplement, no verdict: E-IC historical supplement (one historical price series through the synthetic simulator, no third-party depth, point estimates, not a replay and not E-IC's rule): blocks 25,147,070 to 26,443,420; edge-12h net +11.282 / +1.123 ETH at NAV 1,850 / 185; gated bots edge-12h does not beat: none; E-IC stays NOT RUN. supplement
        E0bDoes the allocation ledger close within 0.3 bp per epoch?FAIL · claim withdrawn59 of 112 epoch rows above the bound, worst 4.09 bp. The closure claim is withdrawn.
        Earlier configurations (published as failed, final) and records
        IDWhatVerdictResult
        U-ICIncentives, earlier six-hour formFAILTwo comparisons failed at 120% volatility. The same six-hour form failed again on U-IC2's paths (reported).
        E0Ledger closure, registered formFAILWorst residual 58.6 bp in an epoch.
        E0aLedger closure, amended formFAIL0.556 bp in one epoch of one run.
        E0b-fitLedger fit data used to set up E0bno verdictFit data.

        Claim coverage at P6 (CLAIMS_PHASE=P6 python3 script/claims.py): 104 of 106 current claim IDs covered, with E5 (FAIL, control form) and E-IC (not run) missing; + 3 historical failed (E0, E0a, U-IC); + 1 withdrawn (E0b: registered test failed, claim dropped).

        Limits

        We publish what failed next to what passed.

        What we found and fixed, and the honest limitsThirteen items. Each names its result file or test.
        • Attack tests (E5): FAIL (control form) under the registered rule. Every asserted attack row in all 17 cells nets ≤ 0; 14 cells have a control test that profits with the defence removed; N1 and N2 have inline sensitivity checks; N3 is a forgery cell. Under the rule as amended after the data: PASS. E5
        • Reported, not asserted. Some attack rows net a positive amount: +0.93 (a markout past the cap, about 8e-4 of NAV), +0.004 (protocol fee on), +0.0006 (off-leg stops), +0.00023 per exit (parking, test tier; about 5e-6 of NAV on mainnet). Token units of a 1,150-NAV test vault. E5
        • Lag leak. Prices lag the market by a block. The settlement closes the gap in expectation, not on every draw. The reserve caps one settlement. E8
        • Incentives are simulated. U-IC2 passed on synthetic paths without an outside observer. With an outside observer, two lax strategies out-earn the reference curator at 120% volatility (by 0.151 and 0.102 ETH). Without one, the vault ends with more value under those lax strategies in every volatility bucket (at 120%: about 558 and 569 against 314, from 1,000). U-IC2 On the supplement's one historical path, too, the vault ends with less value under the reference curator than under a lazy one: about 1,346 against 1,911 ETH from 1,850, with no third-party flow.
        • E-IC was not run. One historical price path was run as a supplement. It gives no verdict; its labelled line is in the Results table. E-IC
        • Market moves are yours. Positioning and token mix are not covered. Skill is not rewarded. The reference TWAP is assumed not to be moved; moving it costs money (E8).
        • One block builder. A single builder that wins every block of the 120 s window and censors arbitrage is outside the model. Against it the safe vault size is about 150 WETH, not the 1,850 WETH cap.
        • The NAV cap is checked at the last action. A vault left unplaced through a large move can hold more than the cap (about +25% after a 50% move).
        • Allocation ledger claim withdrawn. E0b failed: 59 of 112 epoch rows exceeded 0.3 bp (worst 4.09 bp). The ledger is disclosure only and never affects pay. E0b
        • Found and fixed: earlier configurations. E0 and E0a (earlier ledger formulas) failed and stay published. U-IC (the 6-hour wait) failed twice and stays published; the 12-hour wait was then tested separately as U-IC2, and passed. See the history under Results.
        • Synthetic paths, plus one historical path. Every registered simulated result uses simulated 180-day paths. One supplement uses one historical price series. It has no third-party flow.
        • No third-party review yet. The tests, evaluations and SECURITY.md are the evidence.
        • Testnet only. Mock tokens and our own small reference pool. The evidence for a deep reference is the mainnet-fork test.

        Glossary

        Fifteen words, each built on the ones before it.

        Every underlined term on this page opens here. Hover a term to read it in place.

        Pool
        A shared pot of two tokens (here USDC, a dollar token, and ETH) that anyone can trade against. The mix in the pot sets the price.
        Spot price
        The pool's price right now, in the current block (about every 12 seconds on Ethereum).
        Vault and shares
        A joint account that puts depositors' tokens into a pool. Each depositor owns shares. The vault's total value (its NAV) divided by the shares is the price of one share.
        Manager (curator)
        The one party allowed to move the vault's money: where it sits and when it trades. The code calls it the curator.
        Range
        The price window in which the vault's money is placed in the pool and earns trading fees. Here it is about ±10% wide and must hold the price. Outside it, the money sits idle.
        Tick
        The pool's unit of price: one tick is a 0.01% step. 60 ticks is about 0.6%; the 2,000-tick range is about ±10%.
        Reference price
        The average price of the last 10 minutes on a separate, much larger pool, chosen once when the vault is created (a TWAP, time-weighted average price). It is expensive to push because that pool is deep.
        Fence
        A 60-tick band around the reference price. The manager may act only while the spot price is inside it. Outside, the action is refused.
        Execution cost (implementation shortfall)
        After each manager action, the vault prices its holdings before and after, at the spot price and at the reference price, and uses whichever makes the action look worst. The drop is the execution cost. A gain never earns the manager anything, and never offsets a loss.
        Base fee
        The manager's pay: 2.2% a year of the money actually placed in range, earned only while the spot price and the reference price are both inside the range.
        Deferred pay and vesting
        Pay is held back for four to five weeks (four to five epochs of 7 days) before it becomes the manager's to keep (it vests). It vests only while the reference price is in range.
        Bond
        Money the manager posts up front as first loss: 0.174% of the vault's value (1.74 ETH per 1,000; at least 1.74 ETH on mainnet settings). It is taken only after the deferred pay is used up.
        Charge
        The execution cost, taken in full from deferred pay, then from the bond. If the two cannot cover it plus a small reserve, the action is refused. A charge burns the manager's shares, so every other share is worth a little more.
        Markout (settlement)
        Prices on a blockchain lag by a block, so a manager could trade on a stale price. Two minutes later the vault checks the trade again against the deep market's price over those two minutes, and takes up to a further 0.06% of the vault's value from the manager if the trade looks worse. The manager cannot know that price when acting.
        Breach (a strike)
        24 hours of observed time with the reference price outside the range. A breach forfeits all deferred pay, burned for the benefit of every share and released over 7 days. Three breaches remove the manager.

        For builders and AI agents

        The live deployment. Real addresses.

        Unichain Sepolia, chain 1301. DEMO tier. Deployed 2026-11-20 from commit a829357. The manager on this page is the curator in code.

        ContractRoleAddress
        TouchstoneVaultShares, pay, bond, modes0xA8FD240dEFEBE61200C67e8FBfbF8BFC4597b962
        TouchstoneVaultExtensionVault entries behind its fallback0x498E3364Bda8b2dEd92cC6fF06DA8b173df8a9B1
        TouchstoneHookReference, fence, breach clock0x93700F94801eB5542313c87c22cd6c59e875e0A0
        TouchstoneFactoryDeploys vault, extension and hook0x68b4C7D0a58f66d4f8c49B493370824a191e1fE1
        CuratorBundlerThe curator (owner-only calls)0xeccbecA62ffCC13f78890BA9481f7D8649f6Ae31
        PoolManagerUniswap v40x00B036B58a818B1BC34d502D3fE730Db729e62AC
        Reference poolMock-token v3 pool, 0.05%0x84517dBDaa924A8d9bc2abb97BAAB40A648EC972
        Reference driverMoves the mock reference pool along the price path0x9D6c8584760a35FEa1537E76667A7fB237eE5acF
        mUSDC (token0)Mock token0x2295cd39Ad6FC4355B7fBf400567D32E9d070EF2
        mWETH (token1)Mock token0xC39161F7D7b8890c14b070758D23a1c849C2D36c

        Deploy tx 0xd85e…73dd · m_perBlock 697,615,423 from its Deployed event · first range [195,380, 197,380] · source: deployments-1301.json

        Calls

        # the demo tokens are mock tokens; only the deployer can mint them
        # depositor: approve the vault for both tokens first; shares, then the most you will pay of each token
        cast send $TOKEN0 "approve(address,uint256)" $VAULT $MAX0
        cast send $TOKEN1 "approve(address,uint256)" $VAULT $MAX1
        cast send $VAULT "deposit(uint256,uint256,uint256,address)" $SHARES $MAX0 $MAX1 $TO
        
        # withdraw in kind, any mode: shares, then the least you accept of each token
        cast send $VAULT "withdraw(uint256,uint256,uint256,address)" $SHARES $MIN0 $MIN1 $TO
        
        # curator actions go through the CuratorBundler (its owner only); the vault rejects other callers
        # LO, HI aligned to tick spacing 10; moveTo 0 = no move; MAX_CHARGE caps charge + reserve, in token1
        cast send $BUNDLER "setPositions(int24,int24,(bool,bool,uint128),uint160,uint256)" $LO $HI "(false,false,0)" 0 $MAX_CHARGE
        cast send $BUNDLER "rebalanceSwap(bool,uint128,uint256)" $ZERO_FOR_ONE $AMOUNT_IN $MAX_CHARGE
        
        # anyone: settle a closed markout window; poke the clock
        cast send $VAULT "settle()"
        cast send $VAULT "poke()"
        Summary for agents
        Touchstone, DEMO deployment. Unichain Sepolia, chain id 1301. Testnet only.
        Explorer: https://sepolia.uniscan.xyz/
        
        vault             0xA8FD240dEFEBE61200C67e8FBfbF8BFC4597b962
        vault extension   0x498E3364Bda8b2dEd92cC6fF06DA8b173df8a9B1
        hook              0x93700F94801eB5542313c87c22cd6c59e875e0A0
        factory           0x68b4C7D0a58f66d4f8c49B493370824a191e1fE1
        curator bundler   0xeccbecA62ffCC13f78890BA9481f7D8649f6Ae31  (the curator; owner-only)
        pool manager      0x00B036B58a818B1BC34d502D3fE730Db729e62AC
        reference pool    0x84517dBDaa924A8d9bc2abb97BAAB40A648EC972  (mock-token Uniswap v3, 0.05%)
        reference driver  0x9D6c8584760a35FEa1537E76667A7fB237eE5acF  (moves the mock reference pool)
        token0 mUSDC      0x2295cd39Ad6FC4355B7fBf400567D32E9d070EF2
        token1 mWETH      0xC39161F7D7b8890c14b070758D23a1c849C2D36c
        
        DEMO tier (script/Tiers.sol demo()), 1 s blocks:
          reference      300 s TWAP of the reference pool
          fence          60 ticks: an action farther from the reference reverts Fence() 0xe78b0e36
          range width    2,000 ticks; must contain spot and the reference
          charge         worst shortfall at s0, spot and reference; unvested pay, then bond;
                         uncoverable reverts Insolvent() 0xfc220038
          markout        20 s window, opens one block after the action; settle() after it
          cooldown       30 blocks between curator actions
          cure window    1,800 blocks (30 min) out of range = one breach; 3 breaches remove the curator
          epoch          3,600 blocks (1 h)
          base rate      m_perBlock 697,615,423 (WAD-scaled: 6.98e-10 of NAV per block; 2.2% a year)
          bond           1.74e-3 of NAV, minimum 1.74 mWETH; NAV cap 1,850 mWETH
        
        Pool: tick spacing 10. Tokens are mock tokens; only the deployer can mint them.
        Depositor: approve the vault for token0 and token1, then
                   deposit(uint256 shares, uint256 max0, uint256 max1, address to)
                   withdraw(uint256 shares, uint256 min0, uint256 min1, address to)  any mode
        Curator (via the bundler, owner only):
                   setPositions(int24 lo, int24 hi, (bool active, bool zeroForOne, uint128 amountIn) preSwap,
                                uint160 moveTo, uint256 maxCharge)
                   lo, hi aligned to the tick spacing; moveTo is a sqrtPriceX96, 0 = no move;
                   maxCharge caps charge + reserve, in token1 units (else MaxCharge())
                   rebalanceSwap(bool zeroForOne, uint128 amountIn, uint256 maxCharge)
        Anyone:    settle(), poke()
        
        Mainnet tier differs: 12 s blocks, 600 s reference window on USDC/WETH 0.05%
        (0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640), 120 s markout, cure 7,200 blocks (24 h), epoch 50,400 blocks (7 d).
        Not deployed on mainnet. No third-party review. Source: https://github.com/mishoko/touchstone/blob/815c186f8a63f31c65b3d9584fc2fbbe207f4951/

        Reproduce

        forge build --sizes src                      # every runtime ≤ 22,000 B
        FORK_BLOCK_1=26443420 forge test             # needs MAINNET_RPC_URL for the fork tests
        CLAIMS_PHASE=P6 python3 script/claims.py     # claim IDs → tests and result files
        python3 script/mutate.py --audit             # the curated mutant list
        python3 model/reference.py --selfcheck       # the independent model