Simplify smart contract development

Summary

This issue comes from the need to simplify smart contract development on Dusk by abstracting away implementation details like the static mut STATE and no_mangle functions.

It follows from the discussion in the issue Investigate foreign trait exposing.

Possible solution design or implementation

We can create a #[contract] macro that generates the necessary boilerplate code automatically. We can take and extend the functionality of the piecrust-macros I did here, and make it do the following:

The #[contract] macro should be applicable to a Rust module.
The macro should generate no_mangle functions for all public methods within impl blocks.
The macro should generate no_mangle functions for every trait implementation function.
The macro should automatically generate static mut STATE for a public struct defined within the module.
The macro should allow only one public struct.

Example

The following input:

#![no_std]

use piecrust_macros::contract;

#[contract]
pub mod counter {
    pub struct Counter {
        value: i64,
    }

    impl Counter {
        pub fn read_value(&self) -> i64 {
            self.value
        }

        pub fn increment(&mut self) {
            let value = self.value + 1;
            self.value = value;
        }
    }

    pub trait Resettable {
        fn reset(&mut self);
    }

    impl Resettable for Counter {
        fn reset(&mut self) {
            self.value = 0;
        }
    }
}

Should generate the following output:

#![no_std]

use piecrust_uplink as uplink;

pub mod counter {
    pub struct Counter {
        value: i64,
    }

    static mut STATE: Counter = Counter { value: 0 };

    impl Counter {
        pub fn read_value(&self) -> i64 {
            self.value
        }

        pub fn increment(&mut self) {
            let value = self.value + 1;
            self.value = value;
        }
    }

    pub trait Resettable {
        fn reset(&mut self);
    }

    impl Resettable for Counter {
        fn reset(&mut self) {
            self.value = 0;
        }
    }
}

#[no_mangle]
pub unsafe fn read_value(arg_len: u32) -> u32 {
    uplink::wrap_call(arg_len, |_: ()| STATE.read_value())
}

#[no_mangle]
pub unsafe fn increment(arg_len: u32) -> u32 {
    uplink::wrap_call(arg_len, |_: ()| STATE.increment())
}

#[no_mangle]
pub unsafe fn reset(arg_len: u32) -> u32 {
    uplink::wrap_call(arg_len, |_: ()| STATE.reset())
}

By implementing this feature set, developers no longer need to create the no_mangle functions and do not have to define the state explicitly.

dusk-network / dev-tools