2

I've put together a minimum working example, and you can see it here: https://github.com/synthesis-labs/near-mwe. In summary: I have a simple macro that checks that the owner (an arbitrary definition in the context of a struct of the contract) has a particular identity. This is just a simple expansion and insertion into the AST of the function.

When I build this with a classic cargo build then the build works fine and the macro expands appropriately; however to deploy smart contracts I need to build for a WASM-32 target; and then the project fails to compile. Interestingly if I remove the #[near_bindgen] directive then I can build for the WASM-32 target and the macro expands correctly.

The error I get when compiling with the #[near_bindgen] included and for the WASM-32 target is as follows:

cargo build --target wasm32-unknown-unknown

error[E0424]: expected value, found module `self`
  --> src/main.rs:13:5
   |
13 |     #[state_safe]
   |     ^^^^^^^^^^^^^ `self` value is a keyword only available in methods with a `self` parameter
14 |     pub fn change_owner(&mut self, new_owner: String) -> () {
   |            ------------ this function can't have a `self` parameter

I can successfully build the project without the --target wasm32-unknown-unknown or I can remove the #[near_bindgen] and build it with the --target wasm32-unknown-unknown directive.

Mike
  • 59
  • 5

3 Answers3

1

It looks like near_bindgen is not playing nicely with your macro. I have noticed that near_bindgen only instruments public functions, so is it possible to seperate your two concerns like this:

#[near_bindgen]
impl Main {
    #[state_safe]
    fn change_owner(&mut self, new_owner: String) -> () {
        self.owner = new_owner;
    }

    pub fn change_owner_pub(&mut self, new_owner: String) -> () {
        self.change_owner(new_owner)
    }
}

Probably not exactly what you want, but might be a decent workaround until someone figures out a better solution.

Tom Wells
  • 1,159
  • 2
  • 9
  • 15
  • This is super close, and investigating this ultimately led me to discover that the macro was being executed twice! Thank you for your suggestion! – Mike Mar 31 '23 at 09:11
1

Figured it out!

#[near_bindgen] causes the macro to be evaluated twice. The second evaluation occurs when the #[near_bindgen] macro is generating the extern bindings for the NEAR contract, and this only occurs when building for the wasm32 target.

By parsing the macro token stream for the signatures of the #[near_bindgen] bindings I can drop out of the second invocation of the macro, thereby not inserting invalid code into the bindings:

    if input.to_string().contains("target_arch = \"wasm32\"") {
        return input;
    }
Mike
  • 59
  • 5
0

Maybe try Replacing the state_safe macro with the code it generates?

#[near_bindgen]
impl Contract {
    pub fn change_owner(&mut self, new_owner: String) {
        assert_eq!(env::signer_account_id(), self.owner, "Only the owner can perform this action");
        self.owner = new_owner;
    }
}
Daksh Babbar
  • 1