Enum ContractInstruction 

pub enum ContractInstruction {
    Deploy {
        code: Vec<u8>,
        init_data: Vec<u8>,
    },
    Call {
        function: String,
        args: Vec<u8>,
        value: u64,
    },
    Upgrade {
        code: Vec<u8>,
    },
    Close,
    SetUpgradeTimelock {
        epochs: u32,
    },
    ExecuteUpgrade,
    VetoUpgrade,
}

Smart contract instruction types

Variants

Deploy

Deploy new contract Accounts: [deployer (signer, writable), contract (writable)] Data: WASM bytecode

Fields

code: Vec<u8>

WASM bytecode

init_data: Vec<u8>

Initial storage data (optional)

Call

Call contract function Accounts: [caller (signer, writable), contract (writable), …] Data: function name + arguments

Fields

function: String

Function name to call

args: Vec<u8>

Function arguments (serialized)

value: u64

Value to transfer (in spores)

Upgrade

Upgrade contract (only owner can upgrade) Accounts: [owner (signer), contract (writable)] Data: new WASM bytecode

Fields

code: Vec<u8>

New WASM bytecode

Close

Close contract and withdraw remaining balance Accounts: [owner (signer), contract (writable), destination (writable)]

SetUpgradeTimelock

Set or update the upgrade timelock for a contract. Once set, upgrades are staged for N epochs before execution. Setting to 0 removes the timelock (instant upgrades again). Accounts: [owner (signer), contract (writable)]

Fields

epochs: u32

Number of epochs to delay between submission and execution. 0 removes the timelock.

ExecuteUpgrade

Execute a previously staged upgrade after the timelock has expired. Accounts: [owner (signer), contract (writable)]

VetoUpgrade

Veto (cancel) a pending upgrade. Only the governance authority can veto. Accounts: [governance_authority (signer), contract (writable)]

Implementations

impl ContractInstruction

pub fn serialize(&self) -> Result<Vec<u8>, String>

Serialize instruction to bytes

pub fn deserialize(data: &[u8]) -> Result<ContractInstruction, String>

Deserialize instruction from bytes

pub fn deploy(code: Vec<u8>, init_data: Vec<u8>) -> ContractInstruction

Create deploy instruction

pub fn call(function: String, args: Vec<u8>, value: u64) -> ContractInstruction

Create call instruction

pub fn upgrade(code: Vec<u8>) -> ContractInstruction

Create upgrade instruction

pub fn close() -> ContractInstruction

Create close instruction

pub fn set_upgrade_timelock(epochs: u32) -> ContractInstruction

Create set upgrade timelock instruction

pub fn execute_upgrade() -> ContractInstruction

Create execute upgrade instruction

pub fn veto_upgrade() -> ContractInstruction

Create veto upgrade instruction

Trait Implementations

impl Clone for ContractInstruction

fn clone(&self) -> ContractInstruction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ContractInstruction

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContractInstruction

fn deserialize<__D>( __deserializer: __D, ) -> Result<ContractInstruction, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ContractInstruction

fn eq(&self, other: &ContractInstruction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ContractInstruction

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ContractInstruction

impl StructuralPartialEq for ContractInstruction