Cross-Chain State Synchronization System Development

Cross-Chain State Synchronization System

State synchronization is broader than token bridges. Smart contract on chain B must "know" state of smart contract on chain A and react to changes. Examples: governance vote on Ethereum applies to protocol on Arbitrum; NFT bought on Polygon unlocks content on Solana; lending position on Optimism used as collateral on Base.

Requires general purpose cross-chain messaging not just tokens. And solving finality: when can chain B trust state from chain A?

Finality Problem

Optimistic: accept after soft finality, challenge window for rollback. Works for non-financial state.

Conservative: wait hard finality (L1-anchored). 10-30 min for L2. For financial data.

ZK-Verification: Trustless Solution

Destination chain verifies ZK proof about source chain state. Storage Proof via Herodotus: prove specific storage slot value on another chain. Verified on-chain through Merkle-Patricia proof.

Practical Architecture: General Message Passing

For most projects ZK light client too complex/expensive. Use GMP via Axelar/LayerZero/Wormhole with sound security parameters.

// Source: send state
contract StateSender {
    struct GameState {
        address player;
        uint256 score;
        uint256 level;
        uint256 timestamp;
    }
    
    function syncPlayerState(
        string calldata destChain,
        string calldata destAddress,
        address player
    ) external payable {
        GameState memory state = GameState({
            player: player,
            score: playerScores[player],
            level: playerLevels[player],
            timestamp: block.timestamp
        });
        
        bytes memory payload = abi.encode(state);
        gasService.payNativeGasForContractCall{value: msg.value}(
            address(this), destChain, destAddress, payload, msg.sender
        );
        gateway.callContract(destChain, destAddress, payload);
    }
}

// Destination: receive and apply
contract StateReceiver is AxelarExecutable {
    function _execute(
        string calldata sourceChain,
        string calldata sourceAddress,
        bytes calldata payload
    ) internal override {
        require(authorized[sourceChain][sourceAddress], "Unauthorized");
        
        GameState memory state = abi.decode(payload, (GameState));
        require(state.timestamp > syncedState[state.player].timestamp, "Stale");
        
        syncedState[state.player] = state;
        emit StateSynced(sourceChain, state.player, state.score);
    }
}

Idempotency and Ordering

Messages may arrive out of order or duplicate.

mapping(string => mapping(address => uint256)) public lastSeq;
mapping(bytes32 => bool) public processed;

function _execute(string calldata source, string calldata addr, bytes calldata payload) internal override {
    bytes32 msgId = keccak256(abi.encode(source, addr, payload));
    require(!processed[msgId], "Already processed");
    processed[msgId] = true;
    
    (GameState state, uint256 seq) = abi.decode(payload, (GameState, uint256));
    require(seq == lastSeq[source][state.player] + 1, "Out of order");
    lastSeq[source][state.player] = seq;
    
    _applyState(state);
}

Batching for High-Frequency Updates

For games/trading, sync every change on-chain is inefficient. Batch updates off-chain, send Merkle root.

class StateSyncWorker {
  private pending = new Map();
  private syncInterval = 30_000; // 30 sec
  
  queueUpdate(playerId: string, state: PlayerState) {
    this.pending.set(playerId, state);
  }
  
  async flushBatch() {
    if (this.pending.size === 0) return;
    
    const batch = Array.from(this.pending.entries());
    this.pending.clear();
    
    const leaves = batch.map(([id, state]) =>
      keccak256(abi.encode(id, state))
    );
    const merkleRoot = new MerkleTree(leaves).getRoot();
    
    await stateSyncContract.submitBatch(merkleRoot, batch.length);
    await batchStore.save(merkleRoot, batch);
  }
}

Timeline

Basicsync (2 chains, Axelar, ordered): 3-4 weeks. Merkle-batched with off-chain worker + ZK proof: 8-12 weeks. ZK light client (Succinct/Herodotus): 12-20 weeks.