Enum MagicBlockInstruction 

pub enum MagicBlockInstruction {
    ModifyAccounts {
        accounts: HashMap<Pubkey, AccountModificationForInstruction>,
        message: Option<String>,
    },
    ScheduleCommit,
    ScheduleCommitAndUndelegate,
    AcceptScheduleCommits,
    ScheduledCommitSent((u64, u64)),
    ScheduleBaseIntent(MagicBaseIntentArgs),
    ScheduleTask(ScheduleTaskArgs),
    CancelTask {
        task_id: i64,
    },
    DisableExecutableCheck,
    EnableExecutableCheck,
    Noop(u64),
    ScheduleIntentBundle(MagicIntentBundleArgs),
    CreateEphemeralAccount {
        data_len: u32,
    },
    ResizeEphemeralAccount {
        new_data_len: u32,
    },
    CloseEphemeralAccount,
    ScheduleCommitFinalize {
        request_undelegation: bool,
    },
}

Variants

ModifyAccounts

Modify one or more accounts

Account references

• 0. [WRITE, SIGNER] Validator Authority
• 1..n. [WRITE] Accounts to modify
• n+1 [SIGNER] (Implicit NativeLoader)

Fields

accounts: HashMap<Pubkey, AccountModificationForInstruction>

message: Option<String>

ScheduleCommit

Schedules the accounts provided at end of accounts Vec to be committed. It should be invoked from the program whose PDA accounts are to be committed.

This is the first part of scheduling a commit. A second transaction MagicBlockInstruction::AcceptScheduleCommits has to run in order to finish scheduling the commit.

Account references

• 0. [WRITE, SIGNER] Payer requesting the commit to be scheduled
• 1. [WRITE] Magic Context Account containing to which we store the scheduled commits
• 2..n [] Accounts to be committed

ScheduleCommitAndUndelegate

This is the exact same instruction as MagicBlockInstruction::ScheduleCommit except that the [ScheduledCommit] is flagged such that when accounts are committed, a request to undelegate them is included with the same transaction. Additionally the validator will refuse anymore transactions for the specific account since they are no longer considered delegated to it.

This is the first part of scheduling a commit. A second transaction MagicBlockInstruction::AcceptScheduleCommits has to run in order to finish scheduling the commit.

Account references

• 0. [WRITE, SIGNER] Payer requesting the commit to be scheduled
• 1. [WRITE] Magic Context Account containing to which we store the scheduled commits
• 2..n [] Accounts to be committed and undelegated

AcceptScheduleCommits

Moves the scheduled commit from the MagicContext to the global scheduled commits map. This is the second part of scheduling a commit.

It is run at the start of the slot to update the global scheduled commits map just in time for the validator to realize the commits right after.

Account references

• 0. [SIGNER] Validator Authority
• 1. [WRITE] Magic Context Account containing the initially scheduled commits

ScheduledCommitSent((u64, u64))

Records the attempt to realize a scheduled commit on chain.

The signature of this transaction can be pre-calculated since we pass the ID of the scheduled commit and retrieve the signature from a globally stored hashmap.

We implement it this way so we can log the signature of this transaction as part of the MagicBlockInstruction::ScheduleCommit instruction. Args: (intent_id, bump) - bump is needed in order to guarantee unique transactions

ScheduleBaseIntent(MagicBaseIntentArgs)

Schedules execution of a single base intent.

A “base intent” is an atomic unit of work executed by the validator on the Base layer, such as:

• executing standalone base actions (BaseActions)
• committing a set of accounts (Commit)
• committing and undelegating accounts, optionally with post-actions (CommitAndUndelegate)

This instruction is the legacy/single-intent variant of scheduling. For batching multiple independent intents into a single instruction, see MagicBlockInstruction::ScheduleIntentBundle.

Account references

• 0. [WRITE, SIGNER] Payer requesting the intent to be scheduled
• 1. [WRITE] Magic Context account
• 2..n [] Accounts referenced by the intent (including action accounts)

Data

The embedded MagicBaseIntentArgs encodes account references by indices into the accounts array (compact representation).

ScheduleTask(ScheduleTaskArgs)

Schedule a new task for execution

Account references

• 0. [WRITE, SIGNER] Payer (payer)
• 1. [WRITE] Task context account
• 2..n [] Accounts included in the task

CancelTask

Cancel a task

Account references

• 0. [WRITE, SIGNER] Task authority
• 1. [WRITE] Task context account

Fields

task_id: i64

DisableExecutableCheck

Disables the executable check, needed to modify the data of a program in preparation to deploying it via LoaderV4 and to modify its authority.

Account references

• 0. [SIGNER] Validator authority

EnableExecutableCheck

Enables the executable check, and should run after a program is deployed with the LoaderV4 and we modified its authority

Account references

• 0. [SIGNER] Validator authority

Noop(u64)

Noop instruction

ScheduleIntentBundle(MagicIntentBundleArgs)

Schedules execution of a bundle of intents in a single instruction.

A “intent bundle” is an atomic unit of work executed by the validator on the Base layer, such as:

• standalone base actions
• an optional Commit
• an optional CommitAndUndelegate

This is the recommended scheduling path when the caller wants to submit multiple independent intents while paying account overhead only once.

Account references

• 0. [WRITE, SIGNER] Payer requesting the bundle to be scheduled
• 1. [WRITE] Magic Context account
• 2..n [] All accounts referenced by any intent in the bundle

Data

The embedded MagicIntentBundleArgs encodes account references by indices into the accounts array.

CreateEphemeralAccount

Creates a new ephemeral account with rent paid by a sponsor. The account is automatically owned by the calling program (CPI caller).

Account references

• 0. [WRITE] Sponsor account (pays rent, can be PDA or oncurve)
• 1. [WRITE] Ephemeral account to create (must have 0 lamports)
• 2. [WRITE] Vault account (receives rent payment)

Fields

data_len: u32

Initial data length in bytes

ResizeEphemeralAccount

Resizes an existing ephemeral account, adjusting rent accordingly.

Account references

• 0. [WRITE] Sponsor account (pays/receives rent difference)
• 1. [WRITE] Ephemeral account to resize
• 2. [WRITE] Vault account (holds/receives lamports for rent transfer)

Fields

new_data_len: u32

New data length in bytes

CloseEphemeralAccount

Closes an ephemeral account, refunding rent to the sponsor.

Account references

• 0. [WRITE] Sponsor account (receives rent refund)
• 1. [WRITE] Ephemeral account to close
• 2. [WRITE] Vault account (source of rent refund)

ScheduleCommitFinalize

Schedules the accounts provided at end of accounts Vec to be committed and finalized in a single DLP instruction. It should be invoked from the program whose PDA accounts are to be committed.

This is the first part of scheduling a commit. A second transaction MagicBlockInstruction::AcceptScheduleCommits has to run in order to finish scheduling the commit.

Account references

• 0. [WRITE, SIGNER] Payer requesting the commit to be scheduled
• 1. [WRITE] Magic Context Account containing to which we store the scheduled commits
• 2..n [] Accounts to be committed

Fields

request_undelegation: bool

Implementations

impl MagicBlockInstruction

pub fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Trait Implementations

impl Clone for MagicBlockInstruction

fn clone(&self) -> MagicBlockInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MagicBlockInstruction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MagicBlockInstruction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MagicBlockInstruction

fn eq(&self, other: &MagicBlockInstruction) -> 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 MagicBlockInstruction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MagicBlockInstruction

impl StructuralPartialEq for MagicBlockInstruction