Программа для Solana

Узнайте, как написать простую программу на Rust, которая делегирует и увеличивает счётчик в Solana.

---

Быстрый доступ

Ознакомьтесь с базовым примером счётчика в других реализациях:

GitHub

Нативная реализация на Rust

GitHub

Реализация на Pinocchio

Local Development

Локальная разработка

---

---

Пошаговое руководство

Соберите вашу программу и обновите её с хуками делегирования с помощью Delegation Program от MagicBlockDELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh:

1. Пишите вашу программу на Solana так, как вы обычно это делаете.

2. Добавьте CPI-хуки для делегирования, коммита и отмены делегирования аккаунтов состояния через сессии Эфимер Роллап

   Эти общедоступные средства проверки поддерживаются для разработки. Не забудьте добавить конкретный ER валидатор в свою инструкцию при делегировании:

   • Азия (devnet-as.magicblock.app): MAS1Dt9qreoRMQ14YQuhg8UTZMMzDdKhmkZMECCzk57
   • Европа (devnet-eu.magicblock.app): MEUGGrYPxKk17hCr7wpT6s8dtNokZj5U2L57vjYMS8e
   • США (devnet-us.magicblock.app): MUS3hc9TCw4cGC12vHNoYcCGzJG1txjgQLZWVoeNHNd
   • TEE (tee.magicblock.app): FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA
   • Локальная служба поддержки (localhost): mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev
3. Разверните вашу программу напрямую на Solana с помощью Solana CLI.

4. Отправляйте транзакции без изменений как в сети (on-chain), так и вне сети (off-chain), которые также соответствуют спецификации SVM RPC.

---

Пример Счетчика

Могут потребоваться следующие пакеты программного обеспечения, другие версии также могут быть совместимы:

Программное обеспечение	Версия	Руководство по установке
Solana	2.3.13	Установить Solana
Rust	1.85.0	Установить Rust
Anchor	0.32.1	Установить Anchor
**Node **	24.10.0	Установить Node

Code Snippets

1. Напишите программу

Программа реализует две основные инструкции:

• InitializeCounter: Инициализирует счётчик и устанавливает его в 0 (вызывается на базовом слое, Base Layer)

• IncreaseCounter: Увеличивает инициализированный счётчик на X (вызывается на базовом слое или в ER)

  Программа реализует специальные инструкции для делегирования и отмены делегирования счётчика:

• Delegate: Делегирует счётчик с базового слоя (Base Layer) в ER (вызывается на базовом слое)

• CommitAndUndelegate: Планирует синхронизацию счётчика из ER в базовый слой и отменяет делегирование счётчика в ER (вызывается в ER)

• Commit: Планирует синхронизацию счётчика из ER в базовый слой (вызывается в ER)

• Undelegate: Отменяет делегирование счётчика на базовом слое (вызывается на базовом слое через CPI валидатора)

Вот основная структура нашей программы:

pub enum ProgramInstruction {
    InitializeCounter,
    IncreaseCounter {
        increase_by: u64
    },
    Delegate,
    CommitAndUndelegate,
    Commit,
    Undelegate {
        pda_seeds: Vec<Vec<u8>>
    }
}

#[derive(BorshDeserialize)]
struct IncreaseCounterPayload {
    increase_by: u64,
}

impl ProgramInstruction {
    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
        // Ensure the input has at least 8 bytes for the variant
        if input.len() < 8 {
            return Err(ProgramError::InvalidInstructionData);
        }

        // Extract the first 8 bytes as variant
        let (variant_bytes, rest) = input.split_at(8);
        let mut variant = [0u8; 8];
        variant.copy_from_slice(variant_bytes);

        Ok(match variant {
            [0, 0, 0, 0, 0, 0, 0, 0] => Self::InitializeCounter,
            [1, 0, 0, 0, 0, 0, 0, 0] => {
                let payload = IncreaseCounterPayload::try_from_slice(rest)?;
                Self::IncreaseCounter {
                    increase_by: payload.increase_by,
                }
            },
            [2, 0, 0, 0, 0, 0, 0, 0] => Self::Delegate,
            [3, 0, 0, 0, 0, 0, 0, 0] => Self::CommitAndUndelegate,
            [4, 0, 0, 0, 0, 0, 0, 0] => Self::Commit,
            [196, 28, 41, 206, 48, 37, 51, 167] => {
                let pda_seeds: Vec<Vec<u8>> = Vec::<Vec<u8>>::try_from_slice(rest)?;
                Self::Undelegate {
                    pda_seeds
                }
            }
            _ => return Err(ProgramError::InvalidInstructionData),
        })
    }
}

Your “Undelegate” instruction must have the exact discriminator. It is never called by you, instead the validator on the Base Layer will callback with a CPI into your program after undelegating your account on ER.

⬆️ Вернуться к началу

2. Делегировать

Делегирование PDA счётчика

Чтобы делегировать PDA счётчика и сделать его доступным для записи в сессии Ephemeral Rollup, нам нужно добавить инструкцию, которая внутри вызывает функцию delegate_account. Функция delegate_account выполнит CPI к программе делегирования, которая после проверки получит владение аккаунтом. После этого эпемерный валидатор сможет начать обработку транзакций на PDA счётчика и предлагать изменения состояния через программу делегирования.

Транзакция (базовый слой): Делегировать

Просмотрите детали транзакций в Solana Explorer

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    pubkey::Pubkey,
    entrypoint::ProgramResult,
    program_error::ProgramError,
};
use ephemeral_rollups_sdk::cpi::{delegate_account, DelegateAccounts, DelegateConfig};

// For Base Layer only
// Set specific validator based on ER, see https://docs.magicblock.gg/pages/get-started/how-integrate-your-program/local-setup
pub fn process_delegate(
\_program_id: &Pubkey,
accounts: &[AccountInfo],
) -> ProgramResult {

    // Get accounts
    let account_info_iter = &mut accounts.iter();
    let initializer = next_account_info(account_info_iter)?;
    let system_program = next_account_info(account_info_iter)?;
    let pda_to_delegate = next_account_info(account_info_iter)?;
    let owner_program = next_account_info(account_info_iter)?;
    let delegation_buffer = next_account_info(account_info_iter)?;
    let delegation_record = next_account_info(account_info_iter)?;
    let delegation_metadata = next_account_info(account_info_iter)?;
    let delegation_program = next_account_info(account_info_iter)?;

    // Optional: client-provided validator or default validator
    let default_validator = pubkey!("mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev"); // Local ER validator
    let validator_pubkey = match validator_account {
        Some(acc_info) => acc_info.key.clone(),
        None => default_validator,
    };

    // Prepare counter pda seeds
    let seed_1 = b"counter_account";
    let seed_2 = initializer.key.as_ref();
    let pda_seeds: &[&[u8]] = &[seed_1, seed_2];

    let delegate_accounts = DelegateAccounts {
        payer: initializer,
        pda: pda_to_delegate,
        owner_program,
        buffer: delegation_buffer,
        delegation_record,
        delegation_metadata,
        delegation_program,
        system_program,
    };

    let delegate_config = DelegateConfig {
        validator: Some(validator_pubkey), // Set delegating ER validator
        ..Default::default()
    };

    delegate_account(delegate_accounts, pda_seeds, delegate_config)?;

    Ok(())

}

⬆️ Вернуться к началу

3. Коммит

Коммитинг, пока PDA делегирован

Эфемерная среда выполнения позволяет зафиксировать состояние PDA, пока он делегирован. Это выполняется вызовом функции commit_accounts.

Транзакция (ЭР): Коммит

Просмотрите детали транзакции в Solana Explorer

Транзакция (базовый слой): Коммит

Просмотр деталей транзакции в Solana Explorer

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    pubkey::Pubkey,
    entrypoint::ProgramResult,
    program_error::ProgramError,
};
use ephemeral_rollups_sdk::ephem::{commit_accounts};

// For ER only
pub fn process_commit(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
) -> ProgramResult {
    // Get accounts
    let account_info_iter = &mut accounts.iter();
    let initializer = next_account_info(account_info_iter)?;
    let counter_account = next_account_info(account_info_iter)?;
    let magic_program = next_account_info(account_info_iter)?;
    let magic_context = next_account_info(account_info_iter)?;

    // Signer should be the same as the initializer
    if !initializer.is_signer {
        msg!("Initializer {} should be the signer", initializer.key);
        return Err(ProgramError::MissingRequiredSignature);
    }

    commit_accounts(
        initializer,
        vec![counter_account],
        magic_context,
        magic_program,
    )?;

    Ok(())
}

⬆️ Вернуться к началу

4. Отменить делегирование

Отмена делегирования PDA

Отмена делегирования PDA выполняется вызовом функции commit_and_undelegate_accounts в рамках какой-либо инструкции. При отмене делегирования фиксируется последнее состояние и возвращается владение PDA программе-владельцу. После отмены делегирования и финализации состояния валидатор создаёт callback CPI в функцию undelegate на базовом слое (Base Layer).

Транзакция (ЭР): Отменить делегирование

Просмотрите детали транзакции в Solana Explorer

Транзакция (базовый слой): Отменить делегирование

Просмотрите детали транзакции в Solana Explorer

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    pubkey::Pubkey,
    entrypoint::ProgramResult,
    program_error::ProgramError,
};
use ephemeral_rollups_sdk::cpi::{undelegate_account};
use ephemeral_rollups_sdk::ephem::{commit_and_undelegate_accounts, commit_accounts};

// For ER only
pub fn process_commit_and_undelegate(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
) -> ProgramResult {
    // Get accounts
    let account_info_iter = &mut accounts.iter();
    let initializer = next_account_info(account_info_iter)?;
    let counter_account = next_account_info(account_info_iter)?;
    let magic_program = next_account_info(account_info_iter)?;
    let magic_context = next_account_info(account_info_iter)?;

    // Signer should be the same as the initializer
    if !initializer.is_signer {
        msg!("Initializer {} should be the signer", initializer.key);
        return Err(ProgramError::MissingRequiredSignature);
    }

    // Commit and undelegate counter_account on ER
    commit_and_undelegate_accounts(
        initializer,
        vec![counter_account],
        magic_context,
        magic_program,
    )?;

    Ok(())

}

// For Base Layer CPI callback
pub fn process_undelegate(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    pda_seeds: Vec<Vec<u8>>
) -> ProgramResult {
    // Get accounts
    let account_info_iter = &mut accounts.iter();
    let delegated_pda = next_account_info(account_info_iter)?;
    let delegation_buffer = next_account_info(account_info_iter)?;
    let initializer = next_account_info(account_info_iter)?;
    let system_program = next_account_info(account_info_iter)?;

    // CPI on Solana
    undelegate_account(
        delegated_pda,
        program_id,
        delegation_buffer,
        initializer,
        system_program,
        pda_seeds,
    )?;

    Ok(())

}

⬆️ Вернуться к началу

---

Расширенные Фрагменты Кода

Изменить размер PDA

При изменении размера делегированного PDA:

• PDA должен иметь достаточно лампортов, чтобы оставаться освобождённым от арендной платы для нового размера аккаунта.
• Если требуется добавить дополнительные лампорты, счётчик-плательщик должен быть делегирован для предоставления недостающей суммы.
• PDA должен принадлежать программе, а транзакция должна включать всех необходимых подписантов для перевода лампортов.
• **Используйте **system_instruction::allocate

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct Counter {
    pub count: u64,
}

// Resize counter account
pub fn resize_counter_account(
    counter_acc: &AccountInfo,
    payer: &AccountInfo,
    program_id: &Pubkey,
    new_size: usize,
    bump: u8,
) -> ProgramResult {
    let rent = Rent::get()?;
    let lamports_required = rent.minimum_balance(new_size);

    let current_lamports = counter_acc.lamports();
    if lamports_required > current_lamports {
        let lamports_to_add = lamports_required - current_lamports;
        invoke_signed(
            &system_instruction::transfer(
                &payer.key,
                &counter_acc.key,
                lamports_to_add,
            ),
            &[payer.clone(), counter_acc.clone()],
            &[&[COUNTER_SEED, &[bump]]],
        )?;
    }

    // Allocate new size
    invoke_signed(
        &system_instruction::allocate(&counter_acc.key, new_size as u64),
        &[counter_acc.clone()],
        &[&[COUNTER_SEED, &[bump]]],
    )?;

    // Assign back to program
    invoke_signed(
        &system_instruction::assign(&counter_acc.key, program_id),
        &[counter_acc.clone()],
        &[&[COUNTER_SEED, &[bump]]],
    )?;

    msg!("Counter account resized to {} bytes", new_size);
    Ok(())
}

⬆️ Вернуться к началу

Делегирование на кривой

Quick Access

GitHub

On-Curve Delegation

Required signers for delegating an on-curve account:

1. On-curve account to be delegated
2. Fee payer

Required instructions for delegating on-curve accounts:

1. Assign System Account to Delegation Program
2. Delegate to Delegation Program

Kit

// Create assign instruction
// The on-curve account must sign this instruction to change its owner
const accountSigner = await cryptoKeyPairToTransactionSigner(userKeypair);
const delegationProgramAddress = address(DELEGATION_PROGRAM_ID.toString());
const assignInstruction = getAssignInstruction({
  account: accountSigner,
  programAddress: delegationProgramAddress,
});

// Create delegate instruction
const delegateInstruction = await createDelegateInstruction({
  payer: feePayerAddress,
  delegatedAccount: userAddress,
  ownerProgram: ownerProgramAddress,
  validator: validatorAddress,
});

// Prepare transaction
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(feePayerAddress, tx),
  (tx) =>
    appendTransactionMessageInstructions(
      [assignInstruction, delegateInstruction],
      tx
    )
);
// Send and confirm transaction (fee payer need to sign, on-curve account cannot be signer since delegated)
const txHash = await connection.sendAndConfirmTransaction(
  transactionMessage,
  [userKeypair, feePayerKeypair],
  { commitment: "confirmed", skipPreflight: true }
);

Direct commit and undelegate through Magic Program only.

Kit

// Create commit and undelegate instruction
const commitAndUndelegateInstruction = createCommitAndUndelegateInstruction(
  userAddress,
  [userAddress]
);

// Prepare transaction
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(feePayerAddress, tx),
  (tx) =>
    appendTransactionMessageInstructions([commitAndUndelegateInstruction], tx)
);

// Send and confirm transaction on ephemeral connection
const txHash = await ephemeralConnection.sendAndConfirmTransaction(
  transactionMessage,
  [userKeypair, feePayerKeypair],
  { commitment: "confirmed", skipPreflight: true }
);

⬆️ Вернуться к началу

---

Solana Explorer

Получайте информацию о ваших транзакциях и аккаунтах в сети Solana:

Solana Explorer

Официальный обозреватель Solana

Solscan

Обозреватель блокчейна Solana

Провайдеры Solana RPC

Отправляйте транзакции и запросы через существующих RPC-провайдеров:

Solana

Бесплатные публичные ноды

Helius

Бесплатные общие ноды

Triton

Выделенные высокопроизводительные ноды

Панель валидаторов Solana

Следите за обновлениями инфраструктуры валидаторов Solana в реальном времени:

Solana Beach

Аналитика по валидаторам

Validators App

Метрики валидаторов

Статус серверов

Подпишитесь на обновления статуса серверов Solana и MagicBlock:

Solana Status

Подписка на обновления статуса серверов Solana

MagicBlock Status

Подписка на статус серверов MagicBlock

---