Home About John Resume/CV References Writing Research



Isomporph is a Zero Knowledge trustless multichain bridge.


Sample Process Flow

At a high level when an event happens on chain 1 we want to trigger a corresponding action on chain 2.

For a simple bridging of funds this looks as follows

  1. Alice deposits 100 TokenX into TokenLocker on Chain 1 (which are locked) **a1
  2. A transaction t1 is triggered in Block b1 and an event e1 is sent
  3. The relayer listens to event e1 and relays the transaction receipt information to Chain 2.
  4. Verifier verifies that t1 is in block b1
  5. Verifier verifies that block b1 is a valid block
  6. Verifier verifies that b1 is in Chain1 canoninical chain
  7. Executor1 triggers a minting of corresponding 100 TokenX∆ on TokenLocker∆ on Chain 2
  8. A transaction t2 is triggered in Block b2 and an event e2 is sent
  9. The relayer listens to event e2 and relays the transaction receipt information to Chain 1.
  10. Verifier verifies that t2 is in block b2
  11. Verifier verifies that block b2 is a valid block
  12. Verifier verifies that b2 is in Chain2 canoninical chain
  13. Executor2 marks the bridge transaction as complete

Proof Components


Proving Mechanisms






The leading NEAR Ethereum Bridge today Near Rainbow Bridge uses an optimistic approach. Following is an excerpt from NearOnEthClient 1.

we adopt the optimistic 2 approach where NearOnEthClient verifies everything in the NEAR header except the signatures. Then anyone can challenge a signature in a submitted header within a 4-hour challenge window. The challenge requires verification of a single Ed25519 signature which would cost about 500k Ethereum gas (expensive, but possible).




Previous proving mechanisms for Polkadot leverage BEEFY (Bridge Effiency Enabling Finality Yielder) 3 an example is Snowbridge 4 which developed their own Interactive Update Protocol 5.

Verification Mechanism

Relayer Mechanisms

Token Lockers



Appendix F: Data Structures

// SealHash returns the hash of a block prior to it being sealed.
func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) {
 hasher := sha3.NewLegacyKeccak256()

 rlp.Encode(hasher, []interface{}{
 return hash
type Transaction struct {
 data txdata    // Consensus contents of a transaction
 time time.Time // Time first seen locally (spam avoidance)

 // caches
 hash atomic.Value
 size atomic.Value
 from atomic.Value

type txdata struct {
 AccountNonce uint64          `json:"nonce"    gencodec:"required"`
 Price        *big.Int        `json:"gasPrice" gencodec:"required"`
 GasLimit     uint64          `json:"gas"      gencodec:"required"`
 Recipient    *common.Address `json:"to"       rlp:"nil"` // nil means contract creation
 Amount       *big.Int        `json:"value"    gencodec:"required"`
 Payload      []byte          `json:"input"    gencodec:"required"`

 // Signature values
 V *big.Int `json:"v" gencodec:"required"`
 R *big.Int `json:"r" gencodec:"required"`
 S *big.Int `json:"s" gencodec:"required"`

 // This is only used when marshaling to JSON.
 Hash *common.Hash `json:"hash" rlp:"-"`


  1. NEAR: ETH-NEAR Rainbow Bridge: a bridge, called Rainbow Bridge, to connect the Ethereum and NEAR blockchains. 

  2. Optimistic Contracts: contracts that accept all information as fact until proven to be non-factual. This allows for a reduction in the cost of verifying data, as on-chain verification would only be necessary when one is sure that the data is false. 

  3. Polkadot: BEEFY: The BEEFY (Bridge Effiency Enabling Finality Yielder) is a secondary protocol to GRANDPA to support efficient bridging between the Polkadot network (relay chain) and remote, segregated blockchains, such as Ethereum, which were not built with the Polkadot interchain operability in mind. 

  4. SnowBridge: Polkadot Verification: use Polkadot’s BEEFY gadget to implement an efficient light client that only needs to verify a very small subset of relay chain validator signatures. 

  5. Snowbridge: Interactive Update Protocol: A prover wants to convince a light client that at least \(1/3\) of validators signed a statement, which they claim that a specific set of at least \(2/3\) of validators do.