All engineering notes
Blockchain infrastructure, architecture record

Cross-Chain Interoperability Node

Most interoperability designs put a bridge contract between two chains and hope the bridge is not the weak point. This node takes the other route: it embeds native clients for several foreign ecosystems directly, so a transaction can express intent across chains without a custodial bridge in the middle. Two decisions define the codebase — signature agility, so the network can migrate to post-quantum cryptography without a hard fork of every account, and an incremental Merkle structure that makes membership provable without revealing the set.

1.5kTypescript files, node runtime
6+Foreign ecosystems, native clients
2 familiesSignature schemes, classical + post-quantum
10Subsystems, client, features, forks, libs, model…

Repository shape

Node runtime with client, features, forks, libs, model, migrations and a benchmark harness

How this is presented

Documented as an architecture record. Running a node proves nothing on a portfolio page; the design decisions are the substance.

Cross-chain intent without a custodial bridge

Follow how a single request touching two ecosystems is verified inside the node rather than handed to an external operator.

Caller / SDKClient surface

Applications, wallets and autonomous agents talking to the node.

Client surfaceServiceOn-chainData storeExternal
Cross-chain transaction

Intent that spans two ecosystems, verified in one place.

Highlights

  • Native clients for six foreign ecosystems, avoiding a custodial bridge as the trust bottleneck.
  • Signature agility: accounts can move to post-quantum schemes without abandoning existing identities.
  • Incremental Merkle trees for set membership proofs that do not disclose the set.
  • Fork management as a first-class subsystem rather than an operational afterthought.
  • Agent tool protocol support, so autonomous agents can transact as first-class network participants.
  • A dedicated benchmark harness kept in-tree, so performance claims are reproducible.

One node, many native chain clients

The node keeps its own consensus and state, but embeds foreign chain clients directly. Cross-chain intent is expressed and verified inside the node instead of being delegated to an external bridge operator.

Node core

Consensus participation, state management, migrations and the network model.

  • Explicit fork subsystem for coordinated protocol upgrades.
  • Migration path maintained in-tree alongside the state model.

Cryptography layer

Signature verification, hashing and zero-knowledge primitives.

  • Classical and post-quantum schemes sit behind one verification interface.
  • Incremental Merkle trees support membership proofs without set disclosure.

Foreign chain clients

Native read and write access to several external ecosystems.

  • Each ecosystem gets a real client rather than a lowest-common-denominator adapter.
  • Cross-chain operations are verified by the node instead of a bridge custodian.

External interfaces

HTTP API, documented schema, naming resolution and agent tooling.

  • OpenAPI surface generated from the running node.
  • Agent tool protocol exposes node capabilities to autonomous callers.

Node subsystems and chain clients

The node runtime is organised around a core that owns consensus and state, with foreign-chain support isolated into its own client layer. 25 units across 4 groups.

Node core

10
clientconfigerrorsfeaturesforkslibsmigrationsmodeltypestests

Foreign chain clients

6
EVMSolanaAptosCosmosMultiversXBitcoin-family

Cryptography

4
Ed25519post-quantum signatureshash primitivesincremental Merkle trees

Interfaces

5
HTTP APIOpenAPI schemaagent tool protocolnaming resolutionbenchmark harness

Stack by layer

Node runtime

TypeScript, Fastify, Swagger/OpenAPI, Benchmark harness

Cryptography

Ed25519, Post-quantum signature schemes, Hash primitives, Incremental Merkle trees

Foreign chain clients

EVM, Solana, Aptos, Cosmos, MultiversX, Bitcoin-family

Interfaces

Agent tool protocol, Naming resolution, Node SDK

Delivered work

Node runtime

  • Consensus participation, state model, migrations and an explicit fork subsystem.
  • Documented HTTP API generated from the running node.
  • In-tree benchmark harness so performance work is reproducible.

Cryptography

  • Unified verification interface across classical and post-quantum signature families.
  • Incremental Merkle trees for non-disclosing membership proofs.
  • Account rebinding path so identities survive a cryptographic migration.

Interoperability

  • Native clients for six foreign ecosystems.
  • Cross-chain execution verified by the node rather than a bridge custodian.
  • Naming resolution and agent tool protocol support.

Key modules

Signature agility

Lets the network outlive its cryptography.

  • Classical and post-quantum schemes behind one interface.
  • Migration authorised by the old key, so identity is preserved.

Native chain clients

Removes the bridge as a trust bottleneck.

  • Real clients per ecosystem rather than a generic adapter.
  • The most expensive part of the codebase, and the reason it exists.

Fork management

Coordinated protocol upgrades as a subsystem.

  • Treated as code, not as an operational runbook.
  • Sits alongside the migration path in-tree.

Presentation approach

How this project is presented

  • Design decisions explained: signature agility, native clients, private membership.
  • Architecture as an interactive flow rather than a running node.
  • Verified subsystem and file counts.

Documentation and notes

Node API reference

Generated schema for the HTTP surface and agent tooling.

Cryptography notes

Signature families, the migration path and the Merkle proof model.

Interoperability map

Which ecosystems have native clients and what each supports.
  • Network and organisation names are intentionally omitted.
  • Post-quantum readiness here means signature agility — the ability to migrate — not a claim that any single scheme is final.
  • Scale figures are counted from the repository.
All 21 engineering notes