Skip to content

How it works

What each part does, what it guarantees, what this build simulates, and where the guarantees stop.

The parts and what each guarantees

Plan registry

A NEAR account running the registry code

Stores each plan’s commitment, its public envelope, the cooling-off state, the enclave allowlist and every receipt.

Guarantees: Refuses any sale outside the public envelope, from a key not on the allowlist, or during a pending change’s cooling-off. Its deploy key was deleted and it has no upgrade method.

Plan account

One NEAR sub-account per plan, with no keys

Holds the plan’s NEP-141 tokens.

Guarantees: With no key, nobody can sign for it. Its code obeys only the registry, so the founder cannot move tokens out or add a key. Anyone can check this on-chain.

Chain Signatures address

An EVM address derived from the registry and the path plan/<id>

Holds the plan’s ERC-20 tokens on their own chain. Nothing is wrapped or bridged.

Guarantees: Only the registry can ask the MPC network to sign for it, and it signs only the EIP-1559 transfer it built itself, never an opaque hash. One signature at a time, with nonces.

Executor enclave

A TEE worker (OutLayer, Intel TDX)

Holds the sealed plan, picks random sale times, checks several price sources and signs each sale request.

Guarantees: Opens a plan only if it matches the on-chain commitment and sits inside the public envelope. Its receipts answer yes/no compliance checks and never publish the plan’s numbers.

Settlement

NEAR Intents through the 1Click API

Swaps each sale into USDC for the beneficiary.

Guarantees: Each sale carries a 1Click-signed quote that the registry checks on-chain. It binds the deposit address, amount, minimum output (from the floor), recipient and proceeds asset, so even a compromised enclave cannot redirect proceeds. A swap with no final answer is in doubt and keeps being checked; it is never assumed to have failed.

Your browser

This app

Seals the plan, computes the commitment and verifies receipts.

Guarantees: The plan leaves the browser only encrypted to an enclave key whose attestation it checked first. The server never sees the plan. The verifier reads the chain directly.

The path of one sale

  1. 1The enclave wakes at a random time and checks the period budget, the floor and the gap since the last sale.
  2. 2It reads prices from at least two sources and a 1Click quote; if they disagree beyond the sealed tolerance, it waits.
  3. 3It signs a request naming the exact transfer, the 1Click deposit address, the minimum output and its yes/no compliance answers.
  4. 4The registry checks the signature and allowlist, then enforces the public envelope itself, records a receipt and moves the tokens (or has the MPC network sign the EVM transfer).
  5. 51Click settles the swap and sends the proceeds to the beneficiary. Anyone can re-check the receipt from chain data.

Even a fully compromised enclave is bounded by the registry: it cannot sell more per sale or per period than the public envelope, below its floor, or more often than its minimum gap. Holders can check each receipt on the public verifier.

What is simulated in this build

Outside systems run for real wherever they can be reached; the rest are simulated on their real APIs and labelled where they are used. The contracts, the cryptography and the browser checks are always real.

  • Enclave

    An executor process on this server with its own keys, sealed storage and a simulated TDX quote, so local runs and tests spend nothing. The live site runs the same logic on OutLayer’s TDX workers.

    In production: An OutLayer worker in Intel TDX.

  • TDX quote vendor key

    A vendor key whose seed is public. Every check the browser runs is real computation, but anyone could sign such a quote, so it proves the wiring only.

    In production: Intel’s attestation collateral.

  • MPC signing network

    On NEAR testnet, the real network: the registry calls v1.signer-prod.testnet. Locally, a signer simulator on the sandbox answers through the same interface and key derivation.

    In production: NEAR Chain Signatures (v1.signer).

  • 1Click

    A simulator on the real API paths (quote, deposit, status), signing quotes in 1Click’s real format with its own key, which can be told to refund, fail or stall. 1Click has no testnet.

    In production: 1click.chaindefuser.com.

  • Price feeds

    Binance and Coinbase, keyless, for listed tokens (NEAR, wNEAR). A newly launched token has no market yet, so it is priced on a seeded simulated market, with per-source offsets to rehearse manipulation.

    In production: Exchange APIs and 1Click quotes, fetched inside the enclave.

  • NEAR

    NEAR testnet with the deployed registry. Tests and offline work use a local NEAR sandbox, whose clock can be moved forward.

    In production: NEAR mainnet.

  • EVM chain

    Sepolia, reached through public RPC endpoints. Tests and offline work use a local Hardhat node.

    In production: An EVM chain such as Ethereum or Base.

Live status

Read just now from the registry and the enclave this app talks to.

Loading system status

Threat model

  • The insider sells enrolled tokens outside the plan

    Stopped by: The plan account has no keys; only allowlisted enclave requests inside the envelope execute; the registry cannot be upgraded.

    Left: Bugs in the registry code.

  • The insider holds tokens that were never enrolled

    Stopped by: Mint the team allocation straight into the plan at launch and publish the enrolled share.

    Left: Tokens outside the plan are not covered.

  • The insider hedges with derivatives

    Stopped by: Disclosure norms; optional attested exchange-account checks.

    Left: Cannot be fully prevented.

  • Front-running by inferring the schedule

    Stopped by: Random timing, delayed disclosure, a public envelope looser than the plan.

    Left: Large sales still move the price.

  • Price manipulation to trigger sales below fair value

    Stopped by: Several sources must agree; the floor is checked against independent prices; minimum output on every quote.

    Left: Costly but possible for illiquid tokens.

  • The operator reads or alters the plan

    Stopped by: The plan is encrypted to the attested enclave key; the commitment is on-chain.

    Left: Trust in the TEE vendor.

  • The enclave is compromised

    Stopped by: Allowlist with revocation; the registry’s public envelope still bounds every sale.

    Left: As for any TEE system.

  • The enclave goes down

    Stopped by: Sales stop (fail safe); no escape hatch for the insider.

    Left: Sales are delayed during an outage.

  • The insider rushes a change before bad news

    Stopped by: Every change is public and waits out the cooling-off; the old plan keeps running.

    Left: A change can loosen the public bounds, but only after a public cooling-off; holders see the new bounds before they apply.

  • A signed request is replayed

    Stopped by: Sequence numbers, expiry and per-plan state in the registry.

    Left: —

Known limits

  • It proves how enrolled tokens were handled, not everything the insider does. Wallets never enrolled and derivative hedges are outside it.
  • Its legal status is untested. It mirrors a 10b5-1 plan, but no regulator recognises it for tokens yet. Its value today is reputational and contractual.
  • Token coverage depends on NEAR Intents and its solvers. Illiquid or unsupported tokens cannot be sold this way.
  • Market impact remains. The plan hides timing, not the fact that supply is being sold.
  • TEE and MPC trust assumptions are explicit, not removed.

How this differs from Wakeless and Charter

Wakeless hides how a trader executes their own order. Charter enforces public rules on a fund.

Neither lets an insider prove to everyone else that they are following a secret plan they committed to in advance, with their allocation locked in a keyless account from launch on its own chain, and a public cooling-off before any change. That proof is the product.

It is also not vesting: vesting decides when tokens unlock. A sales plan governs how they are sold, privately and verifiably.