updates component syntax to match that of contracts with the cairo-plugin-starknet crate

#[component]
mod PositionComponent {
    struct Position {
        x: felt,
        y: felt
    }

    #[view]
    fn is_zero(self: Position) -> bool {
        match self.x - self.y {
            0 => bool::True(()),
            _ => bool::False(()),
        }
    }

    #[view]
    fn is_equal(self: Position, b: Position) -> bool {
        self.x == b.x & self.y == b.y
    }
}

Given all components in a world are deployed by the world, we can compute a components address given it's component id:

let module_id = pedersen("<module_name>");
let address = deploy(
    class_hash=proxy_class_hash,
    contract_address_salt=module_id,
    constructor_calldata_size=0,
    constructor_calldata=[],
    deploy_from_zero=FALSE,
);
IProxy.set_implementation(class_hash);
IPositionComponent.initialize(address, ...);
registry.write(module_id, address);

Currently we don't know the proxy class hash so we can stub that.

starknet-rs provides a helper for computing a contract address: https://github.com/xJonathanLEI/starknet-rs/blob/ab4752f2b26bbb43dec3450e4358d88fa7a496e2/starknet-core/src/utils.rs#L130

The method should be used here: https://github.com/dojoengine/dojo/blob/c9dea00d631ec691a770b21ed00aeb1eb47e84f2/crates/cairo-lang-dojo/src/query.rs#L45

Create a dojo-cli crate with a rough (eventual) api generated by chat gpt below

Usage: dojo [command] [options]

Commands:
  build        Build the project's ECS, outputting smart contracts for deployment
  migrate      Run a migration, declaring and deploying contracts as necessary to update the world
  bind         Generate rust contract bindings
  inspect      Retrieve an entity's state by entity ID

Options:
  -h, --help   Show help information

Command "build":
  Usage: dojo build [options]

  Options:
    -h, --help  Show help information

Command "migrate":
  Usage: dojo migrate [options]

  Options:
    -h, --help     Show help information
    --plan         Perform a dry run and outputs the plan to be executed
    --world_address  World address to run migration on

Command "bind":
  Usage: dojo bind [options]

  Options:
    -h, --help  Show help information

Command "inspect":
  Usage: dojo inspect [options]
  Options:
    -h, --help  Show help information
    --id        Entity ID to retrieve state for
    --world_address  World address to retrieve entity state from

Implement an indexer to index world events in an efficient and easily queryable manner. The database should expose both historical and the current state of the world.

Objects like:

• components
• entities
• systems
• resources

Historical events like:

• component / system / entity registration
• entity state updates
• system calls

The indexer could use the https://github.com/apibara/apibara engine to stream events from starknet and write them to a sqlite db that can be easily replicated and shared with others.

Currently the cairo language server doesn't support dynamic plugin configuration. In the short term, we should create a crate that wraps it and incorporates the dojo plugin.

Basically, we need to copy this file and include the dojo plugin before the starknet plugin:

https://github.com/starkware-libs/cairo/blob/main/crates/cairo-lang-language-server/src/bin/language_server.rs#L18

So far we've planned to use a similar pattern to mud for tracking world state externally, emitting events from the world contract for indexers. I'm wondering if we could instead use the state diff directly, since we can constrain the storage address of the component state in the generated code, for example, the storage location for an entity's position state below would be:

pedersen(keccak('state'), entity_id)

#[contract]
mod PositionComponent {
    struct Position { x: felt, y: felt }

    struct Storage {
        world_address: felt,
        state: Map::<felt, Position>,
    }
}

Given the indexer knows about the components / systems that exist in the world, it could compute the entity the state update corresponds to. The tricky part is the storage address is not reversible, so the indexer would need to track entity id's that have been provisioned and compute/store the component state address.

The upside is the state diff is part of consensus state, so if we do this, clients can verifiably pull world state off rpc nodes using storage proofs, which would allow for light clients ect that don't need to replay all events to reconstruct the world state.

Tagging @fracek @ponderingdemocritus @milancermak for feedback.

Systems operate on entities in the world. In order to define the set of entities to operate on, dojo should expose a query api similar to the bevy engine.

The api should be expressive, allowing developers to easily construct complex queries, which are interpreted, optimized and inlined at compile time to reduce onchain compute.

The interface should follow the bevy interface:

fn move(query: Query<(Position, Health)>) {
    // @NOTE: Loops are not available in Cairo 1.0 yet.
    for (position, health) in query {
        let is_zero = position.is_zero();
    }
    return ();
}

Expansion:

#[contract]
mod MoveSystem {
    struct Storage {
        world_address: felt,
    }

    #[external]
    fn initialize(world_addr: felt) {
        let world = world_address::read();
        assert(world == 0, 'MoveSystem: Already initialized.');
        world_address::write(world_addr);
    }

    #[external]
    fn execute() {
        let world = world_address::read();
        assert(world != 0, 'MoveSystem: Not initialized.');

        let position_id = pedersen("PositionComponent");
        // We can compute the component addresses statically
        // during compilation.
        let position_address = compute_address(position_id);
        let position_entities = IWorld.lookup(world, position_id);

        let health_id = pedersen("HealthComponent");
        let health_address = compute_address(health_id);
        let health_entities = IWorld.lookup(world, health_id);

        let entities = intersect(position_entities, health_entities);

        for entity_id in entities {
            let is_zero = IPosition.is_zero(position_address, entity_id);
        }
    }
}