#145

Only Dust Tel Aviv Hacker Building Report

WTF is dip

Dip is a composable cross-platform application framework in Rust. It allows you build desktop apps, command line tools, games, and [WIP] web, mobile apps under the same scalable Entity Component System architecture. Unique point is that you can share logic between different platforms as a form of plugin. Transforming dip based desktop/web application into a 2D/3D game is as simple as swapping UI plugins targeting different platform. Your core logic stay the same no matter what platform you're targeting. Dip is based on a game engine called Bevy.

Scope of this PR

Provide StarknetLightClientPlugin that wraps Beerus and provide event driven interface for dip/bevy based developers. This is the first web3 plugin that dip offers besides Ledger device integration.

Demo

Very primitive demo of StarknetLightClientPlugin for Bevy game engine. It has desktop window made with React-like declarative UI (dip DesktopPlugin) with a button to fetch block number via Beerus.

I didn't have time to PoC yet but this plugin should also work in other platforms such as Bevy's 3D render plugins, dip CLIPlugin, etc.

• UI window pops up around 1.20 mins. Please be patient while Beerus is synchronising :)

[TODO] Architecture

sequenceDiagram
    participant UI component (VirtualDOM)
    participant Bevy ECS
    participant Light client (Beerus)

Things to improve in the future

Check my review comments for more details

• Synchronisation of Beerus takes some time (around 1.20 mins). UI window should be rendered before staring a synchronisation and show some progress.
• Right now, the RPC request can be trigger from UI but the result is only show in the console. There should be a global state that UI component can be listening to via custom hook, so it can re-render when the state changes.

// Super basic React-like UI component with a button to request block number via Beerus.

#[allow(non_snake_case)]
fn Root(cx: Scope) -> Element {
    let block_number = use_read(&cx, BLOCK_NUMBER); // <- Reading global state via custom hook

    let window = use_window::<UiAction, NoAsyncAction>(&cx); // <- to delegate action to ECS thread

   // rsx macro is the new jsx
    cx.render(rsx! {
        h1 { "Starknet Light Client (Beerus) Plugin Example" }
        
        p { "block_number: {block_number.value}" }

        button {
            onclick: move |_| window.send(UiAction::get_block_number()),
            "Get Block Number",
        }
    })
}

What's next

On this plugin (StraknetLightClientPlugin)

• Support all JSON-RPC methods provided by Beerus.
• Improve application startup time
• Provide visual feedback on synchronisation progress
• Expose Beerus response as a global state so UI component automatically re-renders when the state changes.

My initial intention for this experiment is to be used by Dojo project as a gaming client layer. As described in the previous section, the light client is still in a breeding edge. In the long-run, be able to verify on-chain data via Beerus light client provides great values because we don't have to trust untrusted data coming from full-node provider such as Alchemy or Infura. But for a sake of making playable games, we need more practical solution at least for now.

Apibara plugin

That being said, the next step for dip is to create another plugin that wraps Apibara Rust SDK which Dojo WG is already started working on. It requires game client to trust a server that Apibara is hosted but that would provide more realistic UX.

StarknetRsPlugin

Plugin to directly send JSON-RPC request to full-node without verification. You need to trust full-node provider but it's simpler than going through light client.

Auto Dojo <-> Bevy ECS synchronisation

The plugin should automatically sync on-chain ECS state with ECS on the client side (Bevy). As a gaming/application developer standpoint, they just query Entity/Component in Bevy instead of manually implementing logics to fetch data from the chain and store.