Reading the chain. This page usually appears within a few seconds.
Reading the chain. This page usually appears within a few seconds.
Who sees what
What each part can see, what comes back to you, and what you still trust.
seesnever gets
In 1962 the economist Kenneth Arrow described why data is hard to sell: a buyer cannot judge it without seeing it, and once they have seen it they have little reason to pay.
Arrow's answer: the buyer does not look. For a small fee, an AI looks for them inside sealed hardware and returns a capped verdict. Then they decide.
Sealed hardware means a walled-off part of a computer chip, built so that even the machine's owner cannot read or change the program running inside, and so that the chip can sign a report of exactly which program ran.
A trusted execution environment (TEE, also called an enclave). Arrow's program runs in an Intel TDX TEE on OutLayer's workers; NEAR AI runs its model in Intel TDX with NVIDIA confidential computing. The signed report is a TDX quote: /verify checks it in your browser, nothing on chain checks it, and the guarantee rests on Intel's hardware (trust rows Evaluation and LLM).
In plain words
Every flagged row of the trust table is in a line below, the main ones first. Each line links to its row in the full table at the bottom of this band, which is the source of truth.
19 of 27 trust rows carry a flag. A flag is a limit we name, not something broken:
Check it yourself: npm run verify -- --network mainnet
What you trust, what each part can see, and how to check it. Open risks are marked RISKY, claims we cannot prove NOT PROVEN, and proof still to come TODO.
| Part | Who you trust | Can see | Cannot | How to check |
|---|---|---|---|---|
| Seller data at rest | Nobody (ciphertext; the host is untrusted) | Whoever hosts the file sees each downloader's IP address and user agent. The exact plaintext size is public (ciphertext length minus 40 bytes), as are the column names and the row count | Decrypt | blob_sha256 is on chain and the enclave checks it before reading: shown on mainnet on 14 Nov (listings #1-#3; purchase #1 has listing.blob_sha256 == purchase.h == eval.h, tx Eaj1mPrtdNBWX6p49aDy9M797dsLZ4hyyi51xaKvyAR6). This site keeps sellers' ciphertext in its blob store only while the hosted demo runs; a daily job deletes a stored ciphertext that no Arrow listing points to, 24 hours after upload |
| Program key / PROTECTED_MASTER NOT PROVEN | OutLayer keystore (TDX) and the shared OutLayer master | Inside the TEE | Release to a non-Arrow caller (tested); release to an unpinned wasm (on mainnet the secret row's access rule is WasmHash 6ad7fed4… AND caller arrow-market.near, never changed since it was made) | WasmHash and Predecessor conditions are configured; in-wasm network allowlist. npm run verify -- --network mainnet row I5 reads the rule from chain: one row on outlayer.near, And[WasmHash 6ad7fed4…, Predecessor arrow-market.near], created_at == updated_at (PROVEN on 14 Nov). Negative tests: an attacker account calling OutLayer directly is refused (testnet tx smm9T86m…, mainnet tx Bzzg22r9…). Both call the pinned wasm, so they test the Predecessor condition only; no transaction tests WasmHash |
| OutLayer keystore DAO RISKY | Can export keys on "cessation" | Potentially everything | — | Open risk |
| Evaluation | Intel TDX (OutLayer worker) | Plaintext inside the TEE | Emit anything outside the schema | Open source; attestation wasm_hash |
| LLM NOT PROVEN | NEAR AI gateway (TDX) and the model TEE (TDX + NVIDIA CC) | A 40-row sample and the criteria | Retain data (NEAR AI's zero-data-retention claim is a trust assumption) | /v1/attestation/report shows the endpoint's current attestation, not eval-time; the wasm does not verify quotes itself |
| Wasm to NEAR AI RISKY | TLS (not E2EE) | — | — | Endpoint and model ID are fixed in the source |
| OutLayer coordinator (closed source) | Liveness | Encrypted input | Read secrets | If it fails, the callback gets null and the buyer is refunded: a purchase in full, an eval less the treasury's share of the fee |
| outlayer.near, intents.near contracts RISKY | Their owners (both are upgradable); Arrow depends on them | — | — | Open risk; verify reads historical transactions |
| Arrow operator | Relayer liveness and the gas tank | The encrypted blobs it hosts, and the IP address, 0x address and listing of every payment relayed through /api/relay | Decrypt the blobs it hosts (the site it serves can: Arrow web app row); take funds or change the contract or wasm hash after the lock, since nobody holds a key to the contract, the team included | Locked on mainnet on 14 Nov, lock tx EqBJFvgJrSipYN3yHaPEm68FvKVPEJLzRb64KtnXk75X (block 224538032): arrow-market.near has 0 access keys and 0 intents.near keys, and npm run verify -- --network mainnet row R6 is PROVEN. After the lock the team cannot pause the market; a failing market still keeps 10% of each eval fee |
| Arrow web app (served JavaScript) RISKY | Whoever deploys the site (a modified deploy is not detectable from the page) | Everything the page handles: the file you encrypt and its key, your criteria, your own list's keys, and the signature that derives your viewing key | — | One viewing-key signature derives every past and future verdict key of that wallet for the domain, so served JavaScript that captures it reads them all. The pages run only scripts that carry the page's per-request nonce ('strict-dynamic', no 'unsafe-inline' or 'unsafe-eval'): that stops an injected script, not a modified deploy. For sensitive data use the CLI |
| Relayer account RISKY | Whoever holds the keys of arrow-relayer.arrowhq.near (the team) | The intents it relays: signer, msg, IP | Spend or move user funds: the relayer holds none | The server's relayer key is a function-call key limited to execute_intents on intents.near. The same account also holds a FullAccess key; whoever holds it can drain the relayer's gas or stop /api/relay. The lock of the market contract does not cover this account. The relay's rate limits are per server instance and protect only the relayer's gas: across instances the worst case is about 0.34 NEAR of gas (its balance down to the 0.65 NEAR floor, then the hosted relay pauses) and no user funds; a signed payment still runs once on intents.near |
| Gas tank RISKY | The operator (tops it up) and OutLayer's NEAR charge | — | — | Every eval costs the contract's tank a NEAR charge, whether or not it succeeds. A failed eval keeps the treasury's 10% of its fee, which goes to the treasury and not the tank, so forced failures still run the tank down and op=eval is refused until someone refills it. At most 5 evals are in flight per listing, and the relay limits each signer per server instance |
| NEAR AI API key (inside the OutLayer secret) RISKY | Billing | Usage volume | See content | The mainnet inference key is the NEAR Builders hackathon key. It cannot be topped up and its expiry is not published; if it runs out, evals fail and are refunded less the treasury's 10% share of their fee. |
| 1Click and the PoA bridge (Intents Technology) NOT PROVEN | Short custody during swaps. Base USDC is a bridged token (omft.near) that 1Click swaps into native NEAR USDC, the only token the market accepts; a Solana withdrawal is the reverse swap. The swap is a trust step | Swap transactions | — | 1Click /v0/status, read by npm run verify -- --network mainnet row R4. On mainnet on 14 Nov, 5.00 USDC came in from Base (4.999784 arrived on Intents, Base tx 0x60ff039b3d3ca5f0759f5981433b45050c5de91a805f2b4406084a4cbf04f419) and the seller withdrew 1.00 USDC to Solana (Solana tx 2hkMCjWQWGEGTzVJDUEwANVzRRL5yWpfapAucembXWHovYRWfrCddX2n8dVivtEPa5kk72885tynk8vYQYV7UyHr); both ended SUCCESS. Custody is not shown |
| Output channel | Schema and rule composition | At most 5.68 bits per eval (scored), 1.59 (verdict), counting the one error output, on this channel only; null (Error channel) and instructions (Side channels) come on top | Free text | cargo test -p arrow-core: output_space_is_at_most_51_states, output_le_900_bytes |
| Error channel RISKY | The enclave writes one fixed error output and nothing on stderr; a trap or out-of-fuel run leaves no output | Two failure states on chain: ok:false (refund reason not_ok) and null. Scored mode has at least 52 outcomes and verdict mode 4 (2 bits); the 5.68 and 1.59 bits and the on-chain budget do not count null | Carry data | scripts/dev/stderr-harness.sh covers stderr, the fixed ok:false output and out-of-memory. A key column that expands under normalization (U+FDFA) ends as ok:false, not out of fuel (key_column_normalization_is_capped), and the injection scan reads only the cell prefix the prompt shows. null still comes from OutLayer or worker failures |
| Side channels RISKY | Not closed | time_ms and instructions on chain. Instructions depend on the dataset size and on the buyer's choice of key_column and date_column, so they can reveal a chosen column's non-empty and distinct counts on each eval; they are not counted in the 5.67-bit bound or the budget | — | TODO: the leak-bench timing measurement has not run, so no timing number is published |
| Decision correctness RISKY | Structural gates and the LLM | — | The LLM cannot produce BUY unless the structural gates pass | llm_cannot_buy_without_structural_gates in cargo test -p arrow-core. The quality bench has not run (TODO). Semantic injection on structurally valid data is an open risk |
| Buyer viewing key RISKY | The buyer's EOA signature over a domain-bound message | — | — | Any site that obtains the same signature can derive the key; an EOA is required (EIP-1271 wallets are not deterministic) |
| After purchase NOT PROVEN | Buyer | All data | — | Out of scope (resale is not prevented) |
| Time guard RISKY | The host clock of the OutLayer worker | — | — | The enclave writes an error output when the block timestamp is more than 90 s (eval) or 45 s (release) old; the clock itself is not attested. A release output OutLayer publishes after the yield window is refused, but its k (sealed to the buyer) is public while the buyer keeps the refund |
| Leak budget RISKY | The contract counter | — | — | evals_used rises inside mt_on_transfer and never falls, not even on a refund: a refunded eval still burns budget. A buyer can burn a listing's budget with failing evals |
| OutLayer on mainnet RISKY | Its owners; the contract was upgraded this week | — | — | The program hash is pinned in the listing, the platform underneath it can still change |
| Refund destination | intents.near's own mt_resolve_transfer | — | — | Refunded to your NEAR Intents balance. Moving it back to a Base wallet is a separate 1Click withdrawal. The Arrow contract refunded a failed eval on mainnet (arrow_refund not_ok, mainnet tx 7Gnw32jEcgUwmhdH2T4YtcJoUPS6hdetpTmWpoFqRcos); refunds by mt_resolve_transfer were shown on mainnet before that with a spike contract |
| HTTP 402 wrapper | Nothing: it carries no payment | — | Move funds | accepts is empty on purpose; payment goes through NEAR Intents. curl -i 'https://arrow-market.vercel.app/api/x402/1' answers 402 with X-Arrow-Listing arrow-market.near/1 and an empty accepts |
| 40-row sample to NEAR AI | TLS to the NEAR AI gateway (no E2EE) | The sampled rows leave the enclave to the model TEE | — | Stated here and in the README; see the LLM row |
| Program bytes RISKY | The Arrow site, which serves the wasm file (hash-pinned) | — | Swap the program: the hash is pinned | Served from the Arrow site at arrow-market.vercel.app/program/6ad7fed4….wasm, the same bytes as release/arrow-tee.wasm. set_program tx DkHQdN6rXPcem3B5QWwibgGUU6kAXMPHDVtbJMGC3xvP moved the URL there from testnet FastFS before the lock, and the lock freezes it. Availability depends on the site staying up |