Struct gstd::prog::ProgramGenerator

pub struct ProgramGenerator(/* private fields */);

Helper to create programs without setting the salt manually.

Implementations

impl ProgramGenerator

pub fn get_salt() -> Vec<u8>

Return the salt needed to create a new program.

Salt is an arbitrary byte sequence unique after every function call.

Examples

use gstd::prog::ProgramGenerator;

#[no_mangle]
extern "C" fn handle() {
    let salt = ProgramGenerator::get_salt();
}

pub fn create_program_bytes( code_id: CodeId, payload: impl AsRef<[u8]>, value: u128, ) -> Result<(MessageId, ActorId)>

Create a new program from the already existing on-chain code identified by CodeId.

The function returns an initial message identifier and a newly created program identifier.

The first argument is the code identifier (see CodeId for details). The second and third arguments are the initialization message’s payload and the value to be transferred to the new program.

Examples

Create a new program from the provided code identifier:

use gstd::{msg, prog::ProgramGenerator, CodeId};

#[no_mangle]
extern "C" fn handle() {
    let code_id: CodeId = msg::load().expect("Unable to load");
    let (init_message_id, new_program_id) =
        ProgramGenerator::create_program_bytes(code_id, b"INIT", 0)
            .expect("Unable to create a program");
    msg::send_bytes(new_program_id, b"PING", 0).expect("Unable to send");
}

pub fn create_program_bytes_for_reply( code_id: CodeId, payload: impl AsRef<[u8]>, value: u128, reply_deposit: u64, ) -> Result<CreateProgramFuture>

Same as create_program_bytes, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

See also

• create_program_bytes_for_reply_as

pub fn create_program_bytes_for_reply_as<D: Decode>( code_id: CodeId, payload: impl AsRef<[u8]>, value: u128, reply_deposit: u64, ) -> Result<CodecCreateProgramFuture<D>>

Same as create_program_bytes, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

The output should be decodable via SCALE codec.

See also

• create_program_bytes_for_reply
• https://docs.substrate.io/reference/scale-codec

pub fn create_program_bytes_delayed( code_id: CodeId, payload: impl AsRef<[u8]>, value: u128, delay: u32, ) -> Result<(MessageId, ActorId)>

Same as create_program_bytes, but creates a new program after the delay expressed in block count.

pub fn create_program_bytes_with_gas( code_id: CodeId, payload: impl AsRef<[u8]>, gas_limit: u64, value: u128, ) -> Result<(MessageId, ActorId)>

Same as create_program_bytes, but with an explicit gas limit.

pub fn create_program_bytes_with_gas_for_reply( code_id: CodeId, payload: impl AsRef<[u8]>, gas_limit: u64, value: u128, reply_deposit: u64, ) -> Result<CreateProgramFuture>

Same as create_program_bytes_with_gas, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

See also

• create_program_bytes_with_gas_for_reply_as

pub fn create_program_bytes_with_gas_for_reply_as<D: Decode>( code_id: CodeId, payload: impl AsRef<[u8]>, gas_limit: u64, value: u128, reply_deposit: u64, ) -> Result<CodecCreateProgramFuture<D>>

Same as create_program_bytes_with_gas, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

The output should be decodable via SCALE codec.

See also

• create_program_bytes_with_gas_for_reply
• https://docs.substrate.io/reference/scale-codec

pub fn create_program_bytes_with_gas_delayed( code_id: CodeId, payload: impl AsRef<[u8]>, gas_limit: u64, value: u128, delay: u32, ) -> Result<(MessageId, ActorId)>

Same as create_program_bytes_with_gas, but creates a new program after the delay expressed in block count.

pub fn create_program<E: Encode>( code_id: CodeId, payload: E, value: u128, ) -> Result<(MessageId, ActorId)>

Same as create_program_bytes, but allows initialize program with the encodable payload.

pub fn create_program_for_reply<E: Encode>( code_id: CodeId, payload: E, value: u128, reply_deposit: u64, ) -> Result<CreateProgramFuture>

Same as create_program, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

See also

• create_program_for_reply_as

pub fn create_program_for_reply_as<E: Encode, D: Decode>( code_id: CodeId, payload: E, value: u128, reply_deposit: u64, ) -> Result<CodecCreateProgramFuture<D>>

Same as create_program, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

The output should be decodable via SCALE codec.

See also

• create_program_for_reply
• https://docs.substrate.io/reference/scale-codec

pub fn create_program_delayed<E: Encode>( code_id: CodeId, payload: E, value: u128, delay: u32, ) -> Result<(MessageId, ActorId)>

Same as create_program, but creates a new program after the delay expressed in block count.

pub fn create_program_with_gas<E: Encode>( code_id: CodeId, payload: E, gas_limit: u64, value: u128, ) -> Result<(MessageId, ActorId)>

Same as create_program, but with an explicit gas limit.

pub fn create_program_with_gas_for_reply<E: Encode>( code_id: CodeId, payload: E, gas_limit: u64, value: u128, reply_deposit: u64, ) -> Result<CreateProgramFuture>

Same as create_program_with_gas, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

See also

• create_program_with_gas_for_reply_as

pub fn create_program_with_gas_for_reply_as<E: Encode, D: Decode>( code_id: CodeId, payload: E, gas_limit: u64, value: u128, reply_deposit: u64, ) -> Result<CodecCreateProgramFuture<D>>

Same as create_program_with_gas, but the program will interrupt until the reply is received.

Argument reply_deposit: u64 used to provide gas for future reply handling (skipped if zero).

The output should be decodable via SCALE codec.

See also

• create_program_with_gas_for_reply
• https://docs.substrate.io/reference/scale-codec

pub fn create_program_with_gas_delayed<E: Encode>( code_id: CodeId, payload: E, gas_limit: u64, value: u128, delay: u32, ) -> Result<(MessageId, ActorId)>

Same as create_program_with_gas, but creates a new program after the delay expressed in block count.