Universal ledger diagram: identity, pages, and messages are written on source chains; the client reads them back and verifies fingerprints

TapeUP Universal Ledger

A bridge connects two shores; a metro connects the whole network. Identity, pages, and messages stay on their source chains. TapeUP reads across chains, verifies locally, and composes a unified view: pages render only when hashes match, and messages post only when digests match.

Written on the source chainIndependent reads from multiple stationsPosted after local verificationProtocol reading fee US$0

3ledger types

Identity, pages, and messages share one endpoint coordinate

US$0.001–0.05

Source-chain write budget for one message or page update in a typical L2 environment

US$0

Protocol reading fee US$0: opening pages and reading messages incurs no per-use protocol fee

0

No destination-chain execution prepayment: TapeUP does not execute on the destination chain, so it does not prepay verification networks, executors, or destination gas.

01

Bridges solve execution on the other side. TapeUP solves verifiable reading across the network.

Traditional bridges use verification networks, executors, liquidity providers, or solvers to move messages and assets to the destination chain and trigger execution. They solve for acting on the other side. TapeUP leaves destination execution out and lets clients read and verify the original records on each source chain.

01

Trust concentrates in the translation layer

A destination chain cannot directly know what happened on the source chain. It relies on verification networks, executors, or solvers to provide proofs and execution.

02

Cross-chain half-states are possible

The source operation may be confirmed while destination execution is delayed or fails, requiring retries, refunds, or exception handling.

03

Interfaces and operations keep expanding

Different approaches use different proof formats, error models, fee structures, and monitoring systems. Supporting more chains increases integration and maintenance costs.

04

Frontend pages usually fall outside a bridge's security boundary

A cross-chain protocol can verify messages or assets, but it usually does not verify that the page a user sees matches the version registered by the project.

A bridge path is cut by verification and execution steps in the middle

Bridge execution can leave cross-chain half-states.

  • Expansion increases support and operational surface.Each new chain or route requires configuring security models, execution parameters, fee quotes, and monitoring.
  • Bridges usually do not verify the page a user sees.A user may submit a perfectly valid on-chain transaction through a substituted frontend that does not reflect their actual intent.

02

Track-based accounting, service-map composition.

DeWEB does not execute on the destination chain. It reframes the problem: can source-chain records be read independently, verified, and composed on the client?

Endpoint identity: chain ID × circuit container address

The endpoint ID is determined by chain ID and container address; TapeUP does not assign it. Control follows source-chain container state.

Source of truth: source-chain container state

Page record: version and hash registered on the source chain

Page path, type, version, and content fingerprint are registered by protocol rules; the client renders only content that matches the on-chain registry.

Source of truth: source-chain registry

Message record: original provenance on the sender's source chain

Messages are written to the hub directory and event on the sender's chain; the recipient client reads, verifies, and posts them at the required confirmation depth.

Source of truth: source-chain hub directory

The protocol lays the track. The product runs the service.

TapeOut DeWEB defines endpoints, directories, write rules, and verification rules. TapeUP reads records across chains and composes a universal ledger for users.

DeWEB lays the track; TapeUP draws the service map.

Metro diagram: three chain lines merge into one service map

03

Records are written only on source chains; the view is composed by the client.

DeWEB defines the objects, write rules, and verification rules without prescribing a client interface. TapeUP follows those rules to read and compose the ledger; it does not rewrite any source-chain record.

The endpoint ID is derived from chain ID and container address

Endpoint coordinates need no central assignment by TapeUP.

The endpoint ID combines a zero-padded chain ID with the container address; the container address calculation already includes chain context. The display form uses the chain short name as an area code. The subject is the circuit container, not a platform account.

Conceptual representation only; actual byte lengths and encodings follow the protocol specification.

endpoint.id
endpointId = concat(
        leftPad(chainId, CHAIN_ID_BYTES),
        containerAddress
      )
Hubs deployed at the same address on every chain

The hub is not a vault. It is two directories.

Every enabled chain uses deterministic deployment so the hub address is identical. Inbound entries record the sender container, block, timestamp, and digest; outbound entries record the recipient endpoint and the message's sequence in the recipient directory. The body lives in the send event; the chain retains the directory and fingerprint long term.

Source-chain writes only; no destination execution of foreign-chain messages

No destination-chain queries, no waiting for destination execution.

Senders submit transactions only on the chain that hosts their container. The hub verifies holder identity on that chain, writes the directory entry, and emits an event. The protocol therefore has no half-state such as "burned on the source chain, not minted on the destination," and needs neither a validator quorum nor destination-chain prepayment.

Multiple independent nodes read the same record and verify its fingerprint

If the fingerprint does not match, the message does not exist.

The digest combines reference and payload hashes. The message ID binds the protocol domain, chain ID, hub, recipient endpoint, and recipient sequence. Payloads use elliptic-curve key exchange and authenticated encryption; directories are public, but only the recipient can decrypt the body.

Conceptual representation only; actual byte lengths and encodings follow the protocol specification.

client.verify
function verify(record, payload, confirmations) {
        assert(hash(payload) === record.digest);
        assert(confirmations >= safeDepth(record.chainId));
        return { status: 'confirmed', payload };
      }
Site files are written to containers in chunks, with each chunk hash verified

The page you see, the message you write, and the identity you hold point to the same coordinate.

Site files are chunked into containers, and the site registry records path, type, chunk count, and content hash. Pages and messages share the same container coordinate. Readers fetch chunk by chunk, and every hash must match the registry.

04

Write on your track. Read across the network.

TapeUP is not a new chain. It deterministically composes three kinds of records scattered across source chains into one universal client-side view. All three share a single primary key: the endpoint ID.

Ledger · Identity

The source of truth is the circuit container. The endpoint ID is derived from the chain ID and container address and is unique across the network.

  • Authority comes from the source-chain circuit container: TapeUP reads the container address, control relationship, and confirmation state, then groups it into the unified view by endpoint ID.
  • Transferring the container transfers the subject
  • No central registry required
Circuit container: chain ID and container address form the endpoint ID; transferring the container transfers the subject

Ledger · Pages

The source of truth is the source-chain container and site registry. A block is posted only when multiple nodes return the same chunk and its hash matches the registry.

The site registry records each path and content hash

Ledger · Messages

The source of truth is the source-chain hub directory; the body lives in the event. A message is posted only after its digest is verified and the chain's safe confirmation depth is reached.

Messages reach the recipient endpoint through the hub directory and post only after digest verification

One open, five verification steps

  1. 01Open endpoint
  2. 02Query multiple independent stations
  3. 03Read source-chain directories, events, and files
  4. 04Verify the on-chain registry and content fingerprints
  5. 05Render or post if consistent; mark as pending if confirmation depth is insufficient

Composition rules

Only a matching fingerprint is posted. The unified view lives in every TapeUP client; indexes can speed it up but never become the source of truth.

05

Independent reads, no power to rewrite the ledger.

A station turns "every client scans the network" into "someone is on duty, but riders can still verify." It does only three things: read the ledger, verify fingerprints, and deliver the service map.

A station's identity comes from a designated integrated-circuit container

A station is not a destination-chain executor.

A bridge's power is to stamp approval on the other side; once stamped, the destination mints or executes. A station has no such stamp: it cannot change a source-chain directory, issue a proof that a destination chain must obey, or conjure a page or message.

To become a station, mint the designated integrated circuit on the official TapeOut protocol and connect its container to TapeUP. Transferring the circuit transfers the station's operating rights.

The station network reads each chain independently and cross-checks

What the station network offers each party, and where its limits are.

  • Users:Users do not need a full node for every chain, but the client still performs final verification.
  • Ledger:A single station outage cannot delete source-chain records; switch stations and the view can be rebuilt.
  • Operators:Operators can compete on coverage, reliability, latency, and service quality. The DeWEB protocol charges no per-message bridge fee; RPC, bandwidth, indexing, and client operations may still be provided or priced separately.
  • Permission boundary:Stations cannot rewrite source chains, sign for users, or issue destination execution permits.

06

The core differences between three universal-chain approaches.

The difference is not how many chains you connect, but where trust lives, who executes, and whether pages count as state.

DimensionBridge-style cross-chainTapeOut DeWEB protocolTapeUP Universal Ledger
DeliverableDestination execution or asset arrivalLeaves a verifiable record on the source chainVerifies multi-chain records and composes a unified view
Trust basisVerifier set, executor, solver, or liquidity networkSource-chain consensus and on-chain registrySource-chain consensus, on-chain fingerprints, and local verification
Destination-chain executionYes, usually requires verification and execution componentsNoNo. The client only reads and composes.
Page handlingUsually outside the bridge protocol's scopeRegisters page version and content fingerprintRender only when hashes match
User feesSource gas, verification, relaying, destination execution, or liquidity feesSource-chain write cost onlyReading incurs no per-use protocol fee
Single point of failureRoute, validator, or executor failures can affect deliverySource-chain records do not disappear when one station goes downAny station can be replaced, or the client can rebuild the view
Asset handlingCan move, mint, release, or swap assetsDoes not move assetsKept separate from asset rails: verify first, then choose whether to transfer

07 · Cost comparison

Sending the same ≤1 KB message, with different cost structures.

The comparison below covers a small message in a typical L2 environment. TapeUP delivers verifiable records; LayerZero and CCIP also provide destination-chain verification and execution, so the services are not identical.

TapeUP / DeWEBL2 source-chain write · Reading US$0

US$0.001–0.05

LayerZero V2DVN + Executor + destination execution

US$0.02–1.50

Chainlink CCIPDON + destination-chain gasLimit

US$0.20–3.00

The ranges below are September 2026 product-planning estimates, not fixed protocol pricing or live trading quotes. Actual fees depend on prevailing gas and protocol quotes. Comparison basis: a ≤1 KB message in a typical L2 environment. LayerZero and CCIP also include destination-chain verification and execution, so they are not strictly equivalent services.

OptionBudget for 1,000 messagesEstimated budget gap using matching interval endpointsNotes
TapeUP / DeWEBUS$1–50BaselineSource-chain writes only; US$0 protocol reading fee
LayerZero V2US$20–1,500US$19–1,450Includes DVN, Executor, and destination-chain execution budget
Chainlink CCIPUS$200–3,000US$199–2,950Includes network services and destination-chain execution budget

10,000 operations budget gap

On the same basis, TapeUP costs about US$10–500: roughly US$190–14,500 less than LayerZero and US$1,990–29,500 less than CCIP. The calculation maps interval endpoints; actual fees depend on prevailing gas and protocol quotes.

  • Mainnet fees can rise significantly:If the source chain is Ethereum mainnet or unusually congested, read live gas separately; do not rely on the L2 estimate.
  • Asset bridges are a different deliverable:Intent bridges such as Across deliver assets on the destination chain; TapeUP delivers verifiable records. A single-transfer price is not a like-for-like comparison.
  • Numbers are budgets, not quotes:All fee ranges are for product planning only. Live transactions should read current gas, route parameters, and application-defined fees.

07

Capability boundaries: what TapeUP provides and what it does not.

TapeUP does not replace every bridge. It separates seeing and verifying from moving and executing, so only workflows that truly require execution pay for a bridge.

TapeUP provides

  • Verifiable endpoint identity
  • Page version and content-hash verification
  • Unified reading of cross-chain message records
  • Independent multi-station reads and local composition
  • Distinguishes confirmed and pending states

TapeUP does not provide

  • Cross-chain atomic swaps
  • Automatic destination execution
  • Asset liquidity and price exchange
  • Token minting, unlocking, or redemption guarantees
  • Substitute judgment on regulation, wallet permissions, or contract risk

Visible, verifiable, and rebuildable even if an entry point fails.

Records stay on the source chain, content fingerprints can be verified, and a single entry-point failure can still be rebuilt. That is the universal ledger TapeUP defines.