> ## Documentation Index
> Fetch the complete documentation index at: https://mgb-ru.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Быстрый старт

> Обеспечьте конфиденциальность любого аккаунта состояния программы на Solana с помощью ЭР от MagicBlock и среды доверенного исполнения (СДИ) на Intel TDX.

***

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

Ознакомьтесь с примером:

> [card] [GitHub](https://github.com/magicblock-labs/magicblock-engine-examples/tree/main/anchor-rock-paper-scissor)
>
> Реализация на Anchor

> [card] dApp (Скоро!)
>
> Попробовать сейчас

***

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

Создайте вашу программу и обновите её с хуками разрешений и делегирования, используя Permission Program MagicBlock `ACLseoPoyC3cBqoUtkbjZ4aDrkurZW86v19pXz2XQnp1` и Delegation Program `DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh`:

**1. [Пишите вашу программу](#1-write-program)**

**Пишите вашу программу на Solana как обычно.**

**2. [Добавьте ограничения с помощью перехватчиков разрешений в вашей программе.](#2-restrict)**

Добавьте хуки разрешений для создания и управления контролем доступа, [посмотреть детали](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/how-to-guide/access-control.md)

**3. [Добавьте перехватчики делегирования в вашу программу](#3-delegate)**

**Добавьте хуки делегирования для разрешений и аккаунтов с ограниченным доступом, чтобы применять ограничения.**

> [!NOTE]
>
> Эти общедоступные средства проверки поддерживаются для разработки. Не забудьте добавить конкретный ER валидатор в свою инструкцию при делегировании:
>
> * Азия ([devnet-as.magicblock.app](http://devnet-as.magicblock.app)): `MAS1Dt9qreoRMQ14YQuhg8UTZMMzDdKhmkZMECCzk57`
> * Европа ([devnet-eu.magicblock.app](http://devnet-eu.magicblock.app)): `MEUGGrYPxKk17hCr7wpT6s8dtNokZj5U2L57vjYMS8e`
> * США ([devnet-us.magicblock.app](http://devnet-us.magicblock.app)): `MUS3hc9TCw4cGC12vHNoYcCGzJG1txjgQLZWVoeNHNd`
> * TEE ([tee.magicblock.app](http://tee.magicblock.app)): `FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA`
> * Локальная служба поддержки ([localhost](http://localhost)): `mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev`

**4. [Разверните вашу программу на Solana](#4-deploy)**

Разверните вашу программу на Solana с помощью Anchor CLI.

**5. [Подпишите сообщение пользователя](#5-authorize)**

Подпишите сообщение пользователя, чтобы получить токен авторизации с СДИ-эндпоинта.

**6. [Выполняйте транзакции и проверяйте конфиденциальность](#6-test)**

Запросите токен авторизации и отправляйте конфиденциальные транзакции.

***

## Пример «Камень-Ножницы-Бумага»

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

| **Программное обеспечение** | **Версия** | **Руководство по установке** |
| - | - | - |
| **Solana** | 2.3.13 | [Установите Solana](https://docs.anza.xyz/cli/install) |
| **Rust** | 1.85.0 | [Установите Rust](https://rust-lang.org/tools/install/) |
| **Anchor** | 0.32.1 | [Установите Anchor](https://www.anchor-lang.com/docs/installation) |
| **Node** | 24.10.0 | [**Установите Node**](https://nodejs.org/en/download/current) |

> [!NOTE]
>
> The latest Permission Program requires SDK version [>=0.8.0](https://github.com/magicblock-labs/ephemeral-rollups-sdk). See [migration
> guide](https://github.com/magicblock-labs/ephemeral-rollups-sdk/pull/103) for details.

### Фрагменты Кода

> [tab] 1. Напиши программу
>
> **Простая программа «Камень-Ножницы-Бумага», где игрок может делать выбор и видеть результат:**
>
> ```rust theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}
> #[program]
> pub mod anchor_rock_paper_scissor {
>
>     use super::*;
>
>     // 1️⃣ Create and auto-join as Player 1
>     pub fn create_game(ctx: Context<CreateGame>, game_id: u64) -> Result<()> {
>         let game = &mut ctx.accounts.game;
>         let player1 = ctx.accounts.player1.key();
>
>         game.game_id = game_id;
>         game.player1 = Some(player1);
>         game.player2 = None;
>         game.result = GameResult::None;
>
>         msg!("Game ID: {}", game_id);
>         msg!("Player 1 PDA: {}", player1);
>
>         // initialize PlayerChoice for player 1
>         let player_choice = &mut ctx.accounts.player_choice;
>         player_choice.game_id = game_id;
>         player_choice.player = player1;
>         player_choice.choice = None;
>
>         msg!("Game {} created and joined by {}", game_id, player1);
>
>         Ok(())
>     }
>
>     // 2️⃣ Player 2 joins the game
>     pub fn join_game(ctx: Context<JoinGame>, game_id: u64) -> Result<()> {
>         let game = &mut ctx.accounts.game;
>         let player = ctx.accounts.player.key();
>
>         require!(game.player1 != Some(player), GameError::CannotJoinOwnGame);
>         require!(game.player2.is_none(), GameError::GameFull);
>
>         game.player2 = Some(player);
>
>         // Create PlayerChoice PDA for player 2
>         let player_choice = &mut ctx.accounts.player_choice;
>         player_choice.game_id = game_id;
>         player_choice.player = player;
>         player_choice.choice = None;
>
>         msg!("{} joined Game {} as player 2", player, game_id);
>         Ok(())
>     }
>
>     // 3️⃣ Player makes a choice
>     pub fn make_choice(ctx: Context<MakeChoice>, _game_id: u64, choice: Choice) -> Result<()> {
>         let player_choice = &mut ctx.accounts.player_choice;
>         require!(player_choice.choice.is_none(), GameError::AlreadyChose);
>
>         player_choice.choice = choice.into();
>         msg!(
>             "Player {:?} made choice {:?}",
>             player_choice.player,
>             player_choice.choice
>         );
>
>         Ok(())
>     }
>
>     // 4️⃣ Reveal and record the winner
>     pub fn reveal_winner(ctx: Context<RevealWinner>) -> Result<()> {
>         let game = &mut ctx.accounts.game;
>         let player1_choice = &ctx.accounts.player1_choice;
>         let player2_choice = &ctx.accounts.player2_choice;
>
>         // 1️⃣ Clone choices into game
>         game.player1_choice = player1_choice.choice.clone().into();
>         game.player2_choice = player2_choice.choice.clone().into();
>
>         // 2️⃣ Ensure both players exist
>         let player1 = game.player1.ok_or(GameError::MissingOpponent)?;
>         let player2 = game.player2.ok_or(GameError::MissingOpponent)?;
>
>         // 3️⃣ Ensure both players made a choice
>         let choice1 = game
>             .player1_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>         let choice2 = game
>             .player2_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>
>         // 4️⃣ Determine winner based on choices
>         game.result = match (choice1, choice2) {
>             (Choice::Rock, Choice::Scissors)
>             | (Choice::Paper, Choice::Rock)
>             | (Choice::Scissors, Choice::Paper) => GameResult::Winner(player1),
>
>             (Choice::Rock, Choice::Paper)
>             | (Choice::Paper, Choice::Scissors)
>             | (Choice::Scissors, Choice::Rock) => GameResult::Winner(player2),
>
>             _ => GameResult::Tie,
>         };
>
>         msg!("Result: {:?}", &game.result);
>
>         Ok(())
>     }
>
> }
>
> #[derive(Accounts)]
> #[instruction(game_id: u64)]
> pub struct CreateGame<'info> {
>     #[account(
>         init_if_needed,
>         payer = player1,
>         space = 8 + Game::LEN,
>         seeds = [GAME_SEED, &game_id.to_le_bytes()],
>         bump
>     )]
>     pub game: Account<'info, Game>,
>
>     #[account(
>         init_if_needed,
>         payer = player1,
>         space = 8 + PlayerChoice::LEN,
>         seeds = [PLAYER_CHOICE_SEED, &game_id.to_le_bytes(), player1.key().as_ref()],
>         bump
>     )]
>     pub player_choice: Account<'info, PlayerChoice>,
>
>     #[account(mut)]
>     pub player1: Signer<'info>,
>     pub system_program: Program<'info, System>,
> }
>
> #[derive(Accounts)]
> #[instruction(game_id: u64)]
> pub struct JoinGame<'info> {
>     #[account(
>         mut,
>         seeds = [GAME_SEED, &game_id.to_le_bytes()],
>         bump
>     )]
>     pub game: Account<'info, Game>,
>
>     #[account(
>         init_if_needed,
>         payer = player,
>         space = 8 + PlayerChoice::LEN,
>         seeds = [PLAYER_CHOICE_SEED, &game_id.to_le_bytes(), player.key().as_ref()],
>         bump
>     )]
>     pub player_choice: Account<'info, PlayerChoice>,
>
>     #[account(mut)]
>     pub player: Signer<'info>,
>     pub system_program: Program<'info, System>,
> }
>
> #[derive(Accounts)]
> #[instruction(game_id: u64)]
> pub struct MakeChoice<'info> {
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game_id.to_le_bytes(), player.key().as_ref()],
>         bump
>     )]
>     pub player_choice: Account<'info, PlayerChoice>,
>
>     #[account(mut)]
>     pub player: Signer<'info>,
> }
>
> #[derive(Accounts)]
> pub struct RevealWinner<'info> {
>     #[account(mut, seeds = [GAME_SEED, &game.game_id.to_le_bytes()], bump)]
>     pub game: Account<'info, Game>,
>
>     /// Player1's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player1.unwrap().as_ref()],
>         bump
>     )]
>     pub player1_choice: Account<'info, PlayerChoice>,
>
>     /// Player2's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player2.unwrap().as_ref()],
>         bump
>     )]
>     pub player2_choice: Account<'info, PlayerChoice>,
>     #[account(mut)]
>     pub payer: Signer<'info>,
> }
>
> #[account]
> pub struct Game {
>     pub game_id: u64,
>     pub player1: Option<Pubkey>,
>     pub player2: Option<Pubkey>,
>     pub player1_choice: Option<Choice>,
>     pub player2_choice: Option<Choice>,
>     pub result: GameResult,
> }
> impl Game {
>     pub const LEN: usize = 8                // game_id
>         + (32 + 1) * 2                       // player1, player2
>         + (1 + 1) * 2                        // player1_choice, player2_choice
>         + (1 + 32); // result (1 byte tag + 32 bytes pubkey for Winner variant)
> }
>
> #[derive(AnchorSerialize, AnchorDeserialize, Clone, PartialEq, Eq, Debug)]
> pub enum GameResult {
>     Winner(Pubkey),
>     Tie,
>     None,
> }
>
> #[account]
> pub struct PlayerChoice {
>     pub game_id: u64,
>     pub player: Pubkey,
>     pub choice: Option<Choice>,
> }
> impl PlayerChoice {
>     pub const LEN: usize = 8 + 8 + 32 + 2;
> }
>
> #[derive(AnchorSerialize, AnchorDeserialize, Clone, PartialEq, Eq, Debug)]
> pub enum Choice {
>     Rock,
>     Paper,
>     Scissors,
> }
>
> #[error_code]
> pub enum GameError {
>     #[msg("You already made your choice.")]
>     AlreadyChose,
>     #[msg("You cannot join your own game.")]
>     CannotJoinOwnGame,
>     #[msg("Both players must make a choice first.")]
>     MissingChoice,
>     #[msg("Opponent not found.")]
>     MissingOpponent,
>     #[msg("Game is already full.")]
>     GameFull,
> }
>
> /// ... Other context and accounts for delegation and privacy
>
> ```
>
> [⬆️ Вернуться к началу](#code-snippets)

> [tab] 2. Restrict
>
> Создавайте и обновляйте разрешения на уровне аккаунта для участников через Permission Program от MagicBlock`ACLseoPoyC3cBqoUtkbjZ4aDrkurZW86v19pXz2XQnp1`, [посмотреть детали](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/how-to-guide/access-control.md)
>
> ```rust theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}
> #[program]
> pub mod anchor_rock_paper_scissor {
>
>     use super::*;
>
>     // 4️⃣ Reveal and record the winner
>     pub fn reveal_winner(ctx: Context<RevealWinner>) -> Result<()> {
>         let game = &mut ctx.accounts.game;
>         let player1_choice = &ctx.accounts.player1_choice;
>         let player2_choice = &ctx.accounts.player2_choice;
>         let permission_program = &ctx.accounts.permission_program.to_account_info();
>         let permission_game = &ctx.accounts.permission_game.to_account_info();
>         let permission1 = &ctx.accounts.permission1.to_account_info();
>         let permission2 = &ctx.accounts.permission2.to_account_info();
>         let magic_program = &ctx.accounts.magic_program.to_account_info();
>         let magic_context = &ctx.accounts.magic_context.to_account_info();
>
>         // 1️⃣ Clone choices into game
>         game.player1_choice = player1_choice.choice.clone().into();
>         game.player2_choice = player2_choice.choice.clone().into();
>
>         // 2️⃣ Ensure both players exist
>         let player1 = game.player1.ok_or(GameError::MissingOpponent)?;
>         let player2 = game.player2.ok_or(GameError::MissingOpponent)?;
>
>         // 3️⃣ Ensure both players made a choice
>         let choice1 = game
>             .player1_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>         let choice2 = game
>             .player2_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>
>         // 4️⃣ Determine winner based on choices
>         game.result = match (choice1, choice2) {
>             (Choice::Rock, Choice::Scissors)
>             | (Choice::Paper, Choice::Rock)
>             | (Choice::Scissors, Choice::Paper) => GameResult::Winner(player1),
>
>             (Choice::Rock, Choice::Paper)
>             | (Choice::Paper, Choice::Scissors)
>             | (Choice::Scissors, Choice::Rock) => GameResult::Winner(player2),
>
>             _ => GameResult::Tie,
>         };
>
>         // Update Permissions for reveal
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&game.to_account_info(), true)
>             .authority(&game.to_account_info(), false)
>             .permission(&permission_game.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[GAME_SEED, &game.game_id.to_le_bytes(), &[ctx.bumps.game]]])?;
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&player1_choice.to_account_info(), true)
>             .authority(&player1_choice.to_account_info(), false)
>             .permission(&permission1.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[
>                 PLAYER_CHOICE_SEED,
>                 &player1_choice.game_id.to_le_bytes(),
>                 &player1_choice.player.as_ref(),
>                 &[ctx.bumps.player1_choice],
>             ]])?;
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&player2_choice.to_account_info(), true)
>             .authority(&player2_choice.to_account_info(), false)
>             .permission(&permission2.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[
>                 PLAYER_CHOICE_SEED,
>                 &player2_choice.game_id.to_le_bytes(),
>                 &player2_choice.player.as_ref(),
>                 &[ctx.bumps.player2_choice],
>             ]])?;
>
>         msg!("Result: {:?}", &game.result);
>         Ok(())
>     }
>
>     /// Creates a permission based on account type input.
>     /// Derives the bump from the account type and seeds, then calls the permission program.
>     pub fn create_permission(
>         ctx: Context<CreatePermission>,
>         account_type: AccountType,
>         members: Option<Vec<Member>>,
>     ) -> Result<()> {
>         let CreatePermission {
>             permissioned_account,
>             permission,
>             payer,
>             permission_program,
>             system_program,
>         } = ctx.accounts;
>
>         let seed_data = derive_seeds_from_account_type(&account_type);
>
>         let (_, bump) = Pubkey::find_program_address(
>             &seed_data.iter().map(|s| s.as_slice()).collect::<Vec<_>>(),
>             &crate::ID,
>         );
>
>         let mut seeds = seed_data.clone();
>         seeds.push(vec![bump]);
>         let seed_refs: Vec<&[u8]> = seeds.iter().map(|s| s.as_slice()).collect();
>
>         CreatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&permissioned_account.to_account_info())
>             .permission(&permission)
>             .payer(&payer)
>             .system_program(&system_program)
>             .args(MembersArgs { members })
>             .invoke_signed(&[seed_refs.as_slice()])?;
>         Ok(())
>     }
> }
>
> #[derive(Accounts)]
> pub struct RevealWinner<'info> {
>     #[account(mut, seeds = [GAME_SEED, &game.game_id.to_le_bytes()], bump)]
>     pub game: Account<'info, Game>,
>
>     /// Player1's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player1.unwrap().as_ref()],
>         bump
>     )]
>     pub player1_choice: Account<'info, PlayerChoice>,
>
>     /// Player2's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player2.unwrap().as_ref()],
>         bump
>     )]
>     pub player2_choice: Account<'info, PlayerChoice>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission_game: UncheckedAccount<'info>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission1: UncheckedAccount<'info>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission2: UncheckedAccount<'info>,
>     /// Anyone can trigger this
>     #[account(mut)]
>     pub payer: Signer<'info>,
>     /// CHECK: PERMISSION PROGRAM
>     #[account(address = PERMISSION_PROGRAM_ID)]
>     pub permission_program: UncheckedAccount<'info>,
> }
>
> #[derive(Accounts)]
> pub struct CreatePermission<'info> {
>     /// CHECK: Validated via permission program CPI
>     pub permissioned_account: UncheckedAccount<'info>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission: UncheckedAccount<'info>,
>     #[account(mut)]
>     pub payer: Signer<'info>,
>     /// CHECK: PERMISSION PROGRAM
>     #[account(address = PERMISSION_PROGRAM_ID)]
>     pub permission_program: UncheckedAccount<'info>,
>     pub system_program: Program<'info, System>,
> }
>
> #[derive(AnchorSerialize, AnchorDeserialize, Clone)]
> pub enum AccountType {
>     Game { game_id: u64 },
>     PlayerChoice { game_id: u64, player: Pubkey },
> }
>
> fn derive_seeds_from_account_type(account_type: &AccountType) -> Vec<Vec<u8>> {
>     match account_type {
>         AccountType::Game { game_id } => {
>             vec![GAME_SEED.to_vec(), game_id.to_le_bytes().to_vec()]
>         }
>         AccountType::PlayerChoice { game_id, player } => {
>             vec![
>                 PLAYER_CHOICE_SEED.to_vec(),
>                 game_id.to_le_bytes().to_vec(),
>                 player.to_bytes().to_vec(),
>             ]
>         }
>     }
> }
>
> /// Other context and accounts ...
> ```
>
> [⬆️ Back to Top](#code-snippets)

> [tab] 3. Делегировать
>
> Обеспечьте конфиденциальность аккаунтов через делегирование валидатору TEE с помощью Delegation Program от MagicBlock `DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh`; как аккаунт с разрешением, так и аккаунт с ограниченным доступом должны быть делегированы.
>
> > [!NOTE]
> >
> > These public validators are supported for development. Make sure to add the
> > specific ER validator in your instruction when delegating:
> >
> > <ul>
> >   <li>
> >     Asia (devnet-as.magicblock.app):&#x20;
> >     `MAS1Dt9qreoRMQ14YQuhg8UTZMMzDdKhmkZMECCzk57`
> >   </li>
> >
> >   <li>
> >     EU (devnet-eu.magicblock.app):&#x20;
> >     `MEUGGrYPxKk17hCr7wpT6s8dtNokZj5U2L57vjYMS8e`
> >   </li>
> >
> >   <li>
> >     US (devnet-us.magicblock.app):&#x20;
> >     `MUS3hc9TCw4cGC12vHNoYcCGzJG1txjgQLZWVoeNHNd`
> >   </li>
> >
> >   <li>
> >     TEE (tee.magicblock.app):&#x20;
> >     `FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA`
> >   </li>
> >
> >   <li>
> >     Local ER (localhost):&#x20;
> >     `mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev`
> >   </li>
> > </ul>
>
> ```rust theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}
> #[ephemeral] // This adds undelegation instruction for ER validator
> #[program]
> pub mod anchor_rock_paper_scissor {
>
>     use super::*;
>
>     // Other instructions
>
>     // 4️⃣ Reveal and record the winner
>     pub fn reveal_winner(ctx: Context<RevealWinner>) -> Result<()> {
>         let game = &mut ctx.accounts.game;
>         let player1_choice = &ctx.accounts.player1_choice;
>         let player2_choice = &ctx.accounts.player2_choice;
>         let permission_program = &ctx.accounts.permission_program.to_account_info();
>         let permission_game = &ctx.accounts.permission_game.to_account_info();
>         let permission1 = &ctx.accounts.permission1.to_account_info();
>         let permission2 = &ctx.accounts.permission2.to_account_info();
>         let magic_program = &ctx.accounts.magic_program.to_account_info();
>         let magic_context = &ctx.accounts.magic_context.to_account_info();
>
>         // 1️⃣ Clone choices into game
>         game.player1_choice = player1_choice.choice.clone().into();
>         game.player2_choice = player2_choice.choice.clone().into();
>
>         // 2️⃣ Ensure both players exist
>         let player1 = game.player1.ok_or(GameError::MissingOpponent)?;
>         let player2 = game.player2.ok_or(GameError::MissingOpponent)?;
>
>         // 3️⃣ Ensure both players made a choice
>         let choice1 = game
>             .player1_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>         let choice2 = game
>             .player2_choice
>             .clone()
>             .ok_or(GameError::MissingChoice)?;
>
>         // 4️⃣ Determine winner based on choices
>         game.result = match (choice1, choice2) {
>             (Choice::Rock, Choice::Scissors)
>             | (Choice::Paper, Choice::Rock)
>             | (Choice::Scissors, Choice::Paper) => GameResult::Winner(player1),
>
>             (Choice::Rock, Choice::Paper)
>             | (Choice::Paper, Choice::Scissors)
>             | (Choice::Scissors, Choice::Rock) => GameResult::Winner(player2),
>
>             _ => GameResult::Tie,
>         };
>
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&game.to_account_info(), true)
>             .authority(&game.to_account_info(), false)
>             .permission(&permission_game.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[GAME_SEED, &game.game_id.to_le_bytes(), &[ctx.bumps.game]]])?;
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&player1_choice.to_account_info(), true)
>             .authority(&player1_choice.to_account_info(), false)
>             .permission(&permission1.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[
>                 PLAYER_CHOICE_SEED,
>                 &player1_choice.game_id.to_le_bytes(),
>                 &player1_choice.player.as_ref(),
>                 &[ctx.bumps.player1_choice],
>             ]])?;
>         UpdatePermissionCpiBuilder::new(&permission_program)
>             .permissioned_account(&player2_choice.to_account_info(), true)
>             .authority(&player2_choice.to_account_info(), false)
>             .permission(&permission2.to_account_info())
>             .args(MembersArgs { members: None })
>             .invoke_signed(&[&[
>                 PLAYER_CHOICE_SEED,
>                 &player2_choice.game_id.to_le_bytes(),
>                 &player2_choice.player.as_ref(),
>                 &[ctx.bumps.player2_choice],
>             ]])?;
>
>         msg!("Result: {:?}", &game.result);
>
>         game.exit(&crate::ID)?;
>
>         commit_and_undelegate_accounts(
>             &ctx.accounts.payer,
>             vec![&game.to_account_info()],
>             magic_context,
>             magic_program,
>         )?;
>
>         Ok(())
>     }
>
>     /// Delegate account to the delegation program based on account type
>     /// Set specific validator based on ER, see https://docs.magicblock.gg/pages/get-started/how-integrate-your-program/local-setup
>     pub fn delegate_pda(ctx: Context<DelegatePda>, account_type: AccountType) -> Result<()> {
>         let seed_data = derive_seeds_from_account_type(&account_type);
>         let seeds_refs: Vec<&[u8]> = seed_data.iter().map(|s| s.as_slice()).collect();
>
>         let validator = ctx.accounts.validator.as_ref().map(|v| v.key());
>         ctx.accounts.delegate_pda(
>             &ctx.accounts.payer,
>             &seeds_refs,
>             DelegateConfig {
>                 validator,
>                 ..Default::default()
>             },
>         )?;
>         Ok(())
>     }
> }
>
> #[commit] // adding magic_context and magic_program accounts to context
> #[derive(Accounts)]
> pub struct RevealWinner<'info> {
>     #[account(mut, seeds = [GAME_SEED, &game.game_id.to_le_bytes()], bump)]
>     pub game: Account<'info, Game>,
>
>     /// Player1's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player1.unwrap().as_ref()],
>         bump
>     )]
>     pub player1_choice: Account<'info, PlayerChoice>,
>
>     /// Player2's choice PDA (derived automatically)
>     #[account(
>         mut,
>         seeds = [PLAYER_CHOICE_SEED, &game.game_id.to_le_bytes(), game.player2.unwrap().as_ref()],
>         bump
>     )]
>     pub player2_choice: Account<'info, PlayerChoice>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission_game: UncheckedAccount<'info>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission1: UncheckedAccount<'info>,
>     /// CHECK: Checked by the permission program
>     #[account(mut)]
>     pub permission2: UncheckedAccount<'info>,
>     /// Anyone can trigger this
>     #[account(mut)]
>     pub payer: Signer<'info>,
>     /// CHECK: PERMISSION PROGRAM
>     #[account(address = PERMISSION_PROGRAM_ID)]
>     pub permission_program: UncheckedAccount<'info>,
> }
>
> /// Unified delegate PDA context
> #[delegate] // enable delegation
> #[derive(Accounts)]
> pub struct DelegatePda<'info> {
>     /// CHECK: The PDA to delegate
>     #[account(mut, del)]
>     pub pda: AccountInfo<'info>,
>     pub payer: Signer<'info>,
>     /// CHECK: Checked by the delegate program
>     pub validator: Option<AccountInfo<'info>>,
> }
>
> #[derive(AnchorSerialize, AnchorDeserialize, Clone)]
> pub enum AccountType {
>     Game { game_id: u64 },
>     PlayerChoice { game_id: u64, player: Pubkey },
> }
>
> fn derive_seeds_from_account_type(account_type: &AccountType) -> Vec<Vec<u8>> {
>     match account_type {
>         AccountType::Game { game_id } => {
>             vec![GAME_SEED.to_vec(), game_id.to_le_bytes().to_vec()]
>         }
>         AccountType::PlayerChoice { game_id, player } => {
>             vec![
>                 PLAYER_CHOICE_SEED.to_vec(),
>                 game_id.to_le_bytes().to_vec(),
>                 player.to_bytes().to_vec(),
>             ]
>         }
>     }
> }
>
> ```
>
> [⬆️ Back to Top](#code-snippets)

> [tab] 4. Развернуть
>
> Теперь ваша программа обновлена и готова! Создавайте и разворачивайте её в нужном кластере:
>
> ```bash theme={null}
>   anchor build && anchor deploy
> ```
>
> [⬆️ Вернуться к началу ](#code-snippets)

> [tab] 5. Авторизовать
>
> **Настройте взаимодействие с ER RPC в TEE:**
>
> * Проверьте целостность TEE RPC через [https://pccs.phala.network/tdx/certification/v4](https://pccs.phala.network/tdx/certification/v4)
> * Запросите токен авторизации для пользователя для взаимодействия с TEE-эндпоинтом
>
> ```typescript Web3.js theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}
> import {
>   verifyTeeRpcIntegrity,
>   getAuthToken,
> } from "@magicblock-labs/ephemeral-rollups-sdk";
>
> // Verify the integrity of TEE RPC
> const isVerified = await verifyTeeRpcIntegrity(EPHEMERAL_RPC_URL);
>
> // Get AuthToken before making request to TEE
> const token = await getAuthToken(
>   EPHEMERAL_RPC_URL,
>   wallet.publicKey,
>   (message: Uint8Array) =>
>     Promise.resolve(nacl.sign.detached(message, wallet.secretKey))
> );
> ```
>
> [⬆️ Back to Top](#code-snippets)

> [tab] 6. Тест
>
> Протестируйте вашу программу с подключением к Приватному Эфемер Роллап:
>
> `https://tee.magicblock.app?token=${token}`
>
> > [!NOTE]
> >
> > These public validators are supported for development. Make sure to add the
> > specific ER validator in your instruction when delegating:
> >
> > <ul>
> >   <li>
> >     Asia (devnet-as.magicblock.app):&#x20;
> >     `MAS1Dt9qreoRMQ14YQuhg8UTZMMzDdKhmkZMECCzk57`
> >   </li>
> >
> >   <li>
> >     EU (devnet-eu.magicblock.app):&#x20;
> >     `MEUGGrYPxKk17hCr7wpT6s8dtNokZj5U2L57vjYMS8e`
> >   </li>
> >
> >   <li>
> >     US (devnet-us.magicblock.app):&#x20;
> >     `MUS3hc9TCw4cGC12vHNoYcCGzJG1txjgQLZWVoeNHNd`
> >   </li>
> >
> >   <li>
> >     TEE (tee.magicblock.app):&#x20;
> >     `FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA`
> >   </li>
> >
> >   <li>
> >     Local ER (localhost):&#x20;
> >     `mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev`
> >   </li>
> > </ul>
>
> ### Quick Access
>
> Check out example:
>
> > [card] [GitHub](https://github.com/magicblock-labs/magicblock-engine-examples/tree/main/anchor-rock-paper-scissor)
> >
> > Anchor Implementation
>
> > [card] [dApp (Coming soon!)](https://private-payments.magicblock.app)
> >
> > Play Now
>
> [⬆️ Вернуться к началу](#code-snippets)

***

***

> [card] [Контроль доступа](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/how-to-guide/access-control.md)
>
> Детализированный контроль доступа.

> [card] [Конфиденциальность на блокчейне](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/introduction/onchain-privacy.md)
>
> Механизмы и концепции обеспечения конфиденциальности

> [card] [Авторизация](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/introduction/authorization.md)
>
> Система авторизации

> [card] [Система соответствия требованиям](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/introduction/compliance-framework.md)
>
> Стандарты и руководства по соблюдению требований

### **Solana Explorer**

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

> [card] [Solana Explorer](https://explorer.solana.com/)
>
> Официальный обозреватель Solana

> [card] [Solscan](https://solscan.io/)
>
> Обозреватель блокчейна Solana

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

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

> [card] [Solana](https://solana.com/docs/references/clusters#on-a-high-level)
>
> Бесплатные публичные ноды

> [card] [Helius](https://www.helius.dev/solana-rpc-nodes)
>
> Бесплатные общие ноды

> [card] [Triton](https://triton.one/solana)
>
> Выделенные высокопроизводительные ноды

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

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

> [card] [Solana Beach](https://solanabeach.io/)
>
> Аналитика по валидаторам

> [card] [Validators App](https://www.validators.app/)
>
> Метрики валидаторов

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

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

> [card] [Solana Status](https://status.solana.com/)
>
> Подписка на обновления статуса серверов Solana

> [card] [MagicBlock Status](https://mgb-ru.mintlify.site/pages/overview/additional-information/server-status)
>
> Подписка на статус серверов MagicBlock

***

### **Продукты MagicBlock**

> [card] [Эфемерный роллап (ER)](https://mgb-ru.mintlify.site/pages/ephemeral-rollups-ers/how-to-guide/quickstart.md)
>
> Выполнение транзакций в реальном времени без комиссий и с высокой безопасностью в сети Solana.

> [card] [Приватный эфемерный роллап (PER)](https://mgb-ru.mintlify.site/pages/private-ephemeral-rollups-pers/how-to-guide/quickstart.md)
>
> Защита конфиденциальных данных с помощью приватных вычислений.

> [card] [Проверяемая функция случайности (VRF)](https://mgb-ru.mintlify.site/pages/verifiable-randomness-functions-vrfs/how-to-guide/quickstart.md)
>
> Генерация доказуемо честной случайности напрямую в блокчейне.

***


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.