Bridges move things across; TapeUP reads everything, verifiably

A cross-chain bridge uses a verification network, executors, liquidity providers or solvers to deliver messages and assets to the target chain and trigger execution — it solves "acting on the far side for you". TapeUP does not execute on the target chain; it lets clients read and verify the raw records on each source chain directly.

One line: a bridge links two banks; the metro links the whole grid. The bridge's four old problems:

• Trust sits in a translation layer: the target chain cannot directly know what happened on the source chain, so it relies on a verification network, executor or solver for proof.
• Cross-chain half-states: the source chain confirms but target-chain execution can lag or fail, needing retries and refunds.
• A growing interface and ops surface: every chain or route means another security model, parameters, pricing and monitoring.
• The frontend is usually outside the bridge's safety scope: a bridge can verify a message or an asset, but usually not whether the page you see is the one the project registered.

Three ledgers, one endpoint

Identity, pages and messages share a single coordinate.

The endpoint ID is "left-padded chain ID" plus "container address", with no central allocation by TapeUP; the subject is a circuit container, not a platform account. Conceptually: endpointId = concat(leftPad(chainId, CHAIN_ID_BYTES), containerAddress) (byte lengths and encoding follow the spec).

The Hub is not a vault; it is two directories. Every enabled chain gets the same Hub address via deterministic deployment. An inbox entry records the sender container, block, timestamp and digest; an outbox entry records the recipient endpoint and this message's index in the recipient's directory. The body lives in the send event; what stays on chain long-term is the directory and the fingerprint.

Write only to the source chain; the view is composed on the client

No querying the target chain, no waiting on target-chain execution: the sender submits only on the chain where their container lives, and the Hub merely verifies holder identity on that chain, writes the directory and emits an event. So the protocol produces no "burned on source, not minted on target" half-state, and needs neither a validator quorum nor target-chain prepayment.

If the fingerprint does not match, the letter does not stand: the digest is computed from the reference and the payload hash together; the message number binds the protocol domain, chain ID, Hub, recipient endpoint and recipient index; the payload uses elliptic-curve key exchange and authenticated encryption — the directory is public, the body is readable only by the recipient.

function verify(record, payload, confirmations) {
  assert(hash(payload) === record.digest);
  assert(confirmations >= safeDepth(record.chainId));
  return { status: 'confirmed', payload };
}

One open, five checks: open the endpoint → ask several independent stations → read source-chain directories, events and files → check the on-chain registry against the content fingerprint → render or post if they agree, mark pending if depth is short. Only a matching fingerprint is posted; the unified view lives in every client, and an index can speed things up but cannot be the truth.

The metro station: independent reading, no right to rewrite

A station turns "each client scans everything" into "someone is on duty grid-wide, and riders can still double-check". It does three things: read the ledger, check fingerprints, deliver the timetable.

A station is not a target-chain executor: it cannot change a source-chain directory, cannot issue a proof the target chain must obey, cannot conjure a page or a letter. To become a station you mint a specified integrated circuit on the official TapeOut protocol and connect its container to TapeUP; transfer the circuit and the station's operating rights transfer with it.

For each side: users need not run a full node for every chain, yet the final check is still done by the client; one station going down does not erase source-chain records, and after switching stations the view can be rebuilt; operators compete on coverage, stability and latency, and the DeWEB protocol charges no per-use toll.

How it differs from a bridge, and where it stops

The difference is not how many chains you connect but where trust sits, who executes, and whether the page counts as state.

Budget comparison for a ≤1 KB message (2026-09 product planning range, not a quote): TapeUP / DeWEB source-chain write about US$0.001–0.05, read US$0; LayerZero V2 about US$0.02–1.50; Chainlink CCIP about US$0.20–3.00.

What TapeUP does not do: atomic cross-chain swaps, automatic target-chain execution, asset liquidity and price exchange, token mint/unlock/redemption guarantees, or a substitute for judging regulatory, wallet-permission and contract risk. It splits "see and verify" out of "move and execute", so only businesses that truly need execution pay a bridge.