[discuss] Codegen world interface

[ponderingdemocritus]

We want to minimize boilerplate writing as much as possible while also improving type safety and completion for the best possible developer experience.

One way we can achieve this is by generating a World Class based on the manifest.json, which builds a typed interface for all potential endpoints into the world.

Ideally, the end goal is something like this:

await dojo.play.create({ account, name: "ohayo"})

This would execute the Play system contract and the Create function.

We could achieve this by generating classes like:

(Slayer is the World Name)

export class Slayer extends RPCProvider {
    public play: PlayContract;

    constructor(worldAddress: string, manifest?: any, url?: string) {
        super(worldAddress, manifest, url);
       
        // each system contract would be nested like this
        this.play = new PlayContract(this);
    }
}

interface IPlayContractFunctions {
    create: (props: CreateProps) => Promise<any>;
    seek: (props: Signer) => Promise<any>;
    roll: (props: RollProps) => Promise<any>;
    buy: (props: BuyProps) => Promise<any>;
    apply: (props: ApplyProps) => Promise<any>;
}

export class PlayContract implements IPlayContractFunctions {
    private slayer: Slayer;
    private name: string;

    constructor(provider: Slayer) {
        this.slayer = provider;
        this.name = "play";
    }

    async create(props: CreateProps): Promise<any> {
        try {
            return await this.slayer.execute(
                props.account,
                this.name,
                "create",
                [this.slayer.getWorldAddress(), props.name]
            );
        } catch (error) {
            console.error("Error in creating entity:", error);
            throw error;
        }
    }
}

Since worlds will contain many contracts we need to nest the classes to avoid potential clashes.

This file could be generated by simply:

bun run generate-systems

Looking for feedback on this.

@tarrencev @broody @JunichiSugiura @rsodre @Matth26 @aymericdelab

[theskyvalker]

This functionality would be really awesome. As I am developing with the Dojo stack, I find myself wanting something like this more and more and I actually searched if this was already there for a bit - it makes a lot of sense to have this for developers.

[ponderingdemocritus]

great! Yes, this will be the next big feature - I would suggest to just copy this structure into your project for now.

[Matth26]

Totally agree, after doing almost the same boilerplate for 3 games. Auto-gen with TypeScript would be awesome and definitely would speed up the dev process!

[rsodre]

I like this, the more abstraction the better
Maybe the whole dojo client folder, including DojoContext could be moves to the react package as well

[aymericdelab]

Ohayo, this would be a great feature indeed for lots of projets. Though for Eternum, we mostly use multi calls which would not be possible to automatically generate.

[ponderingdemocritus]

Rethought this a bit. We should avoid classes and be purely functional.

Have been experimenting with interfaces and new structure in the react-app on the PR - #99

Have arrived at something like this which provides a typed interface and avoids strange class inheritence.

export async function setupWorld(provider: DojoProvider) {
    function actions() {
        const contract_name = "actions";

        const spawn = async ({ account }: { account: Account }) => {
            try {
                return await provider.execute(
                    account,
                    contract_name,
                    "spawn",
                    []
                );
            } catch (error) {
                console.error("Error executing spawn:", error);
                throw error;
            }
        };

        const move = async ({
            account,
            direction,
        }: {
            account: Account;
            direction: Direction;
        }) => {
            try {
                return await provider.execute(account, contract_name, "move", [
                    direction,
                ]);
            } catch (error) {
                console.error("Error executing move:", error);
                throw error;
            }
        };
        return { spawn, move };
    }
    return {
        actions: actions(),
    };
}

[rsodre]

Looks clean!

I frequently wonder if I should return anything from system calls when I need to do something when it is finished.
A simple boolean for success/failure, or the tx that I can listen to somewhere else.
(btw, I still don't know how to do that with Dojo, or how to listen for events...)

What I end up doing is returning nothing, and listening to any component that should be updated after the system call

[ponderingdemocritus]

We are adding Katana long polling into this, which will allow fo this. What we really need is to know if it hits Torii and then reflect in the client.