Do You intend to unit test register() and other implementations? Having an Agent field would make it a bit difficult, i guess. Consider using generics with traits to facilitate testing.

It does make sense to do this but I would rather do it for CanisterMethods and then we can unit test the Tracker part. This would be more valuable because the Tracker is basically a state machine with more involved logic than these simple Canister methods.

Can't one use agent-rs directly?

This is what we discussed during standup - this Agent is a different implementation that allows you to specify a Sender, which the regular Agent implementation does not.

drop a comment in code plz

Curios, why do You need Sync + Send here. Is there going to be concurrency involved?

This is required because Register is an async trait.

See my comment above regarding Agent and unit testing. IMO a trait would be useful here for unit testing.

What would we be unit testing though? These are very thin functions that just make use of the underlying agent.

What would we be unit testing though?

You could test for the expected errors, cause ATM this is not possible, i suppose. It's just a suggestion, if this function remains thin, maybe it's an overkill.

#[automock]
#[async_trait]
pub trait ExecutesCalls: Sync + Send {
    async fn execute_update(&self) -> Result<....>;
    async fn execute_query(&self) -> Result<...>;
}

pub struct Canister<Agent> {
    agent: Agent,
}

impl<Agent: ExecutesCalls> Register for Canister<Agent> {
    async fn register(&self) -> Result<(), String> {
        let response = self.agent.execute_update();
        ...
    }
}