> ## Documentation Index
> Fetch the complete documentation index at: https://docs.magicblock.gg/llms.txt
> Use this file to discover all available pages before exploring further.
# Anchor Example
> Learn how to write a simple Anchor program that increments a counter on Solana
This guide will walk you through the process of writing a simple Anchor program that increments a counter. You'll learn how to deploy this program on Solana and interact with it using a React client.
## Software Packages
This program is developed and tested with the following software packages. Other versions may also be compatible.
| Software | Version | Installation Guide |
| ---------- | ------- | --------------------------------------------------------------- |
| **Solana** | 3.1.9 | [Install Solana](https://docs.anza.xyz/cli/install) |
| **Rust** | 1.89.0 | [Install Rust](https://www.rust-lang.org/tools/install) |
| **Anchor** | 1.0.2 | [Install Anchor](https://www.anchor-lang.com/docs/installation) |
## Quick Access to Source Code
If you prefer to dive straight into the code:
## Writing the Anchor Program
Let's break down the key components of our counter program:
## Core Functionality
The program implements two main instructions:
1. `initialize`: Sets the counter to 0
2. `increment`: Increments the counter by 1
Here's the core structure of our program:
```rust theme={null}
#[ephemeral]
#[program]
pub mod public_counter {
use super::*;
/// Initialize the counter.
pub fn initialize(ctx: Context) -> Result<()> {
let counter = &mut ctx.accounts.counter;
counter.count = 0;
Ok(())
}
/// Increment the counter.
pub fn increment(ctx: Context) -> Result<()> {
let counter = &mut ctx.accounts.counter;
counter.count += 1;
Ok(())
}
// ... Additional instructions will be added here
}
```
Nothing special here, just a simple Anchor program that increments a counter. The only difference is that we're adding the `delegate` macro to inject some useful logic to interact with the delegation program.
### Delegating the Counter PDA
In order to delegate the counter PDA, and make it writable in an Ephemeral Rollup session, we need to add an instruction which
internally calls the `delegate_account` function. `delegate_account` will CPI to the delegation program, which upon validation will gain ownership of the account.
After this step, an ephemeral validator can start processing transactions on the counter PDA and propose state diff trough the delegation program.
Inspect transactions details on Solana Explorer
```rust theme={null}
/// Add delegate function to the context
#[delegate]
#[derive(Accounts)]
pub struct DelegateInput<'info> {
pub payer: Signer<'info>,
/// CHECK The pda to delegate
#[account(mut, del)]
pub pda: AccountInfo<'info>,
}
```
```rust theme={null}
/// Delegate the account to the delegation program
/// Set specific validator based on ER, see https://docs.magicblock.gg/pages/get-started/how-integrate-your-program/local-setup
pub fn delegate(ctx: Context) -> Result<()> {
ctx.accounts.delegate_pda(
&ctx.accounts.payer,
&[COUNTER_SEED],
DelegateConfig {
// Optionally set a specific validator from the first remaining account
validator: ctx.remaining_accounts.first().map(|acc| acc.key()),
..Default::default()
},
)?;
Ok(())
}
```
### Committing while the PDA is delegated
The ephemeral runtime allows committing the state of the PDA while it is delegated. This is done by building a `MagicIntentBundleBuilder` with the `commit` intent and invoking it.
Inspect transaction details on Solana Explorer
Inspect transaction details on Solana Explorer
```rust theme={null}
use ephemeral_rollups_sdk::ephem::MagicIntentBundleBuilder;
/// Increment the counter and manually commit the account in the Ephemeral Rollup session.
pub fn increment_and_commit(ctx: Context) -> Result<()> {
let counter = &mut ctx.accounts.counter;
counter.count += 1;
// Serialize the Anchor account before the CPI sees it
counter.exit(&crate::ID)?;
MagicIntentBundleBuilder::new(
ctx.accounts.payer.to_account_info(),
ctx.accounts.magic_context.to_account_info(),
ctx.accounts.magic_program.to_account_info(),
)
.commit(&[ctx.accounts.counter.to_account_info()])
.build_and_invoke()?;
Ok(())
}
```
### Undelegating the PDA
Undelegating the PDA is done by building a `MagicIntentBundleBuilder` with the `commit_and_undelegate` intent.
This commits the latest state and returns ownership of the PDA to the owner program.
Inspect transaction details on Solana Explorer
Inspect transaction details on Solana Explorer
```rust theme={null}
use ephemeral_rollups_sdk::ephem::MagicIntentBundleBuilder;
/// Undelegate the account from the delegation program
pub fn undelegate(ctx: Context) -> Result<()> {
MagicIntentBundleBuilder::new(
ctx.accounts.payer.to_account_info(),
ctx.accounts.magic_context.to_account_info(),
ctx.accounts.magic_program.to_account_info(),
)
.commit_and_undelegate(&[ctx.accounts.counter.to_account_info()])
.build_and_invoke()?;
Ok(())
}
```
## Connecting the React Client
The React client is a simple interface that allows you to interact with the Anchor program.
It uses the Anchor bindings to interact with the program and the MagicBlock SDK to interact with the Ephemeral Rollup session. Source lives alongside the program at [`anchor-counter/app`](https://github.com/magicblock-labs/magicblock-engine-examples/tree/main/anchor-counter/app).
{" "}
Iframes only work with some wallets (e.g. Backpack). Alternatively, try the
deployed demo here: [https://counter-example.magicblock.app/](https://counter-example.magicblock.app/)
### Ephemeral Endpoint Configuration
To interact with the Ephemeral Rollup session, you need to configure the appropriate endpoint:
* For devnet, use the following ephemeral endpoint:
[https://devnet.magicblock.app](https://devnet.magicblock.app)
* For mainnet, please reach out to the MagicBlock team to receive the appropriate endpoint.
* For localhost, download, install, and run the ephemeral validator locally with the appropriate environment variables.
Make sure to update your client configuration to use the correct endpoint based on your development or production environment.
These public RPC endpoints are currently free and supported for development:
Magic Router Devnet: [https://devnet-router.magicblock.app](https://devnet-router.magicblock.app)
Solana Devnet: [https://api.devnet.solana.com](https://api.devnet.solana.com)
ER Devnet: [https://devnet.magicblock.app](https://devnet.magicblock.app)
TEE Devnet: [https://devnet-tee.magicblock.app/](https://devnet-tee.magicblock.app/)
Find out more details{" "}
here
.