Attribute Macro concordium_std::init
source · #[init]
Expand description
Derive the appropriate export for an annotated init function.
This macro requires the following items to be present
contract="<name>"
where <name> is the name of the smart contract and the generated function is exported as this name prefixed with init_. The name should be unique in the module, as a contract can only have one init-function.
The annotated function must be of a specific type, which depends on the enabled attributes. Without any of the optional attributes the function must have a signature of
#[init(contract = "my_contract")]
fn some_init<S: HasStateApi>(ctx: &impl HasInitContext, state_builder: &mut StateBuilder<S>,) -> InitResult<MyState> {...}
Where HasInitContext
, InitResult
, and StateBuilder
are exposed from
concordium-std
and MyState
is a user-defined type.
Optional attributes
payable
: Make function accept an amount of CCD
Without setting the payable
attribute, the generated function will reject
any non-zero amount of CCD supplied with the transaction. This means we are
required to explicitly mark our functions as payable
, if they are to
accept CCD.
Setting the payable
attribute changes the required signature to include an
extra argument of type Amount
, allowing the function to access the amount
of CCD supplied with the transaction.
Example
#[init(contract = "my_contract", payable)]
fn some_init<S: HasStateApi>(ctx: &impl HasInitContext, state_builder: StateBuilder<S>, amount: Amount) -> InitResult<MyState> {...}
enable_logger
: Function can access event logging
Setting the enable_logger
attribute changes the required signature to
include an extra argument &mut impl HasLogger
, allowing the function to
log events.
Example
#[init(contract = "my_contract", enable_logger)]
fn some_init<S: HasStateApi>(ctx: &impl HasInitContext, state_builder: StateBuilder<S>, logger: &mut impl HasLogger) -> InitResult<MyState> {...}
low_level
: Manually deal with the low-level state.
Setting the low_level
attribute disables the generated code for
serializing the contract state.
If low_level
is set, the &mut StateBuilder<S>
in the signature is
replaced by &impl mut HasStateApi
found in concordium-std
, which gives
access to manipulating the low-level contract state directly. This means
there is no need to return the contract state and the return type becomes
InitResult<()>
.
Example
#[init(contract = "my_contract", low_level)]
fn some_init(ctx: &impl HasInitContext, state: &mut impl HasStateApi) -> InitResult<()> {...}
parameter="<Param>"
: Generate schema for parameter
To make schema generation include the parameter for this function, add
the attribute parameter
and set it equal to a string literal containing
the name of the type used for the parameter. The parameter type must
implement the SchemaType trait, which for most cases can be derived
automatically.
Example
#[derive(SchemaType)]
struct MyParam { ... }
#[init(contract = "my_contract", parameter = "MyParam")]
error="<Error>"
: Generate schema for error
To make schema generation include the error for this function, add
the attribute error
and set it equal to a string literal containing
the name of the type used for the error. The error type must
implement the SchemaType trait, which for most cases can be derived
automatically.
Example
#[derive(SchemaType)]
enum MyError { ... }
#[init(contract = "my_contract", parameter = "MyError")]
fn some_init(ctx: &impl HasInitContext, state: &mut impl HasStateApi) -> Result<(), MyError> {...}
crypto_primitives
: Function can access cryptographic primitives
Setting the crypto_primitives
attribute changes the required signature to
include an extra argument &impl HasCryptoPrimitives
, which provides
cryptographic primitives such as verifying signatures and hashing data.
Example
#[init(contract = "my_contract", crypto_primitives)]
fn some_init<S: HasStateApi>(
ctx: &impl HasInitContext,
state_build: StateBuilder<S>,
crypto_primitives: &impl HasCryptoPrimitives,
) -> InitResult<MyState> {...}