Dojo v0.6.0

[glihm]

Dojo Game Engine v0.6.0 Release Notes

Welcome to the next update of the Dojo Game Engine, version 0.6.0. This release brings a suite of enhancements and new features designed to improve performance, extend functionality, and streamline development workflows. We expect this release to be available by March 29 2024.
Let's dive into what's new:

Katana: Enhanced Execution Engine

• Multi-executor engine: Katana now supports both blockifier and starknet_in_rust as execution engines, significantly expanding our capabilities in benchmarking and performance optimization through cairo-native.
• Support for RPC 0.6.0.
• Expanded RPC API namespaces (torii, saya).
• Metrics integration: Katana has now an integrated metrics module with prometheus an grafana dashboard.

Sozo: Streamlined World Building

• Revamped Manifest Format. Sozo introduces a new, comprehensive manifest format in toml, organized across different stages of development. These manifests are designed for clarity and should be version-controlled in .git to track changes in your world efficiently.
  Here are the different manifests folders, under the manifests root directory:

  • base: Generated during the build phase.
  • overlays: For each manifest file present in base, the user can create a new file with the same name and path under the overlays folder. Those files are meant to be edited by developers, to override some values.
  • deployments: Contains the intended state of the world for deployment. Two files are generated when sozo migrate is issued: <CHAIN_ID>.toml and <CHAIN_ID>.json.

  An other folder named abis contains all the ABIs extracted from the contracts for easy access.

• Simplified Contract Syntax. The new syntax for dojo contracts removes unnecessary boilerplate, focusing on the essentials.

  #[dojo::interface]
  trait IActions {
      fn spawn();
      fn move(direction: Direction);
  }

  No more ref self or self. Only the arguments that your system needs.

  Selective world injection in systems, you can now inject the world only where needed. The world: IWorldDispatcher must be the first argument and with this exact casing:

  // Note that the world argument is only used here, not in the interface.
  fn spawn(world: IWorldDispatcher) {
      let my_model = get!(world, ...);
  }
  
  fn other_system() {
      // no world accessible here.
  }

• Enhanced sozo auth Command. Authorizations are usually useful to setup a world and configure it. Sozo now supports multicall for those operations. Also, a new syntax aims at providing a more expressive way to configure the world:

  sozo auth grant writer Moves,0x1234 Position,0x1234
  sozo auth grant owner model:Moves,0x2222 contract:0x1234,0x2222

  Both revoke and grant are now supported.

• Binding generation for Typescript and Unity. To ease the front-end integration of dojo with dojo.js, sozo can now outputs bindings generated from the contracts ABI for typescript and unity.

  sozo build --typescript --unity

• New sozo clean command for tidying up your project space and ensure old artifacts or manifests are removed effectively.

Torii: Advanced Event and State Management

• Event-Driven Models. Torii is now able to reflect the state of some entities that are not stored directly into the world's storage, but emitted as event instead. This opens door to a kind of volition that would be improved in the coming versions. You can find an example of that in the actions.json contract, where a new model Moved
  

  dojo/examples/spawn-and-move/src/actions.cairo

  Lines 24 to 30 in ba1b250

  	#[derive(Model, Copy, Drop, Serde)]
  	#[dojo::event]
  	struct Moved {
  	#[key]
  	player: ContractAddress,
  	direction: Direction,
  	}

  
  

  dojo/examples/spawn-and-move/src/actions.cairo

  Line 87 in ba1b250

  emit!(world, (Moved { player, direction }));

• Integration of long polling, enhanced transaction monitoring for quicker indexing.
• Optimized Transaction Indexing from blocks for faster indexing on mainnet.
• Event query and subscriptions are now supported over gRPC.
• SNIP12 support on Torii, which allows one to send messages directly to the Torii relay. The relay will verify the signature and decode the message to store the entity inside the message. This unlock off-chain data flow, typically for chat systems embedded into an application built with Dojo.

Audit 🛡️

This version has undergone a security audit by Nethermind, ensuring the robustness and security of the core contracts. Read the full report.