use ephemeral_rollups_sdk::access_control::instructions::{
CommitAndUndelegatePermissionCpiBuilder, CreatePermissionCpiBuilder,
DelegatePermissionCpiBuilder,
};
use ephemeral_rollups_sdk::access_control::structs::{Member, MembersArgs, PERMISSION_SEED};
use ephemeral_rollups_sdk::anchor::{commit, delegate, ephemeral};
use ephemeral_rollups_sdk::consts::PERMISSION_PROGRAM_ID;
use ephemeral_rollups_sdk::cpi::DelegateConfig;
use ephemeral_rollups_sdk::ephem::MagicIntentBundleBuilder;
#[ephemeral] // Adds undelegation instruction for the ER validator
#[program]
pub mod private_counter {
use super::*;
/// Delegate the counter privately:
/// 1. Create the permission account
/// 2. Delegate the permission account
/// 3. Delegate the counter itself
pub fn delegate(
ctx: Context<DelegateCounterPrivately>,
members: Option<Vec<Member>>,
) -> Result<()> {
let validator = ctx.accounts.validator.as_ref();
// 1. Create the permission account (skip if it already exists).
if ctx.accounts.permission.data_is_empty() {
CreatePermissionCpiBuilder::new(&ctx.accounts.permission_program)
.permissioned_account(&ctx.accounts.counter.to_account_info())
.permission(&ctx.accounts.permission.to_account_info())
.payer(&ctx.accounts.payer.to_account_info())
.system_program(&ctx.accounts.system_program.to_account_info())
.args(MembersArgs { members })
.invoke_signed(&[&[COUNTER_SEED, &[ctx.bumps.counter]]])?;
}
// 2. Delegate the permission account (skip if already delegated).
if ctx.accounts.permission.owner != &ephemeral_rollups_sdk::id() {
DelegatePermissionCpiBuilder::new(&ctx.accounts.permission_program.to_account_info())
.permissioned_account(&ctx.accounts.counter.to_account_info(), true)
.permission(&ctx.accounts.permission.to_account_info())
.payer(&ctx.accounts.payer.to_account_info())
.authority(&ctx.accounts.counter.to_account_info(), false)
.system_program(&ctx.accounts.system_program.to_account_info())
.owner_program(&ctx.accounts.permission_program.to_account_info())
.delegation_buffer(&ctx.accounts.buffer_permission.to_account_info())
.delegation_metadata(&ctx.accounts.delegation_metadata_permission.to_account_info())
.delegation_record(&ctx.accounts.delegation_record_permission.to_account_info())
.delegation_program(&ctx.accounts.delegation_program.to_account_info())
.validator(validator)
.invoke_signed(&[&[COUNTER_SEED, &[ctx.bumps.counter]]])?;
}
// 3. Delegate the counter (skip if already delegated).
if ctx.accounts.counter.owner != &ephemeral_rollups_sdk::id() {
ctx.accounts.delegate_counter(
&ctx.accounts.payer,
&[COUNTER_SEED],
DelegateConfig {
validator: validator.map(|v| v.key()),
..Default::default()
},
)?;
}
Ok(())
}
/// Undelegate the counter privately:
/// 1. Commit and undelegate the permission account via the Permission Program
/// 2. Commit and undelegate the counter via the ephemeral rollups SDK
///
/// Both intents are scheduled on `magic_context` in the same ER transaction
/// and applied together when the transaction is sealed back to the base layer.
pub fn undelegate(ctx: Context<UndelegateCounter>) -> Result<()> {
// 1. Commit and undelegate the permission account
CommitAndUndelegatePermissionCpiBuilder::new(
&ctx.accounts.permission_program.to_account_info(),
)
.authority(&ctx.accounts.payer.to_account_info(), true)
.permissioned_account(&ctx.accounts.counter.to_account_info(), true)
.permission(&ctx.accounts.permission.to_account_info())
.magic_context(&ctx.accounts.magic_context.to_account_info())
.magic_program(&ctx.accounts.magic_program.to_account_info())
.invoke_signed(&[&[COUNTER_SEED, &[ctx.bumps.counter]]])?;
// 2. Commit and undelegate the counter
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(())
}
}
/// Delegate context for the counter and its permission account.
#[delegate] // Enable delegation
#[derive(Accounts)]
pub struct DelegateCounterPrivately<'info> {
pub payer: Signer<'info>,
/// CHECK: The PDA to delegate
#[account(mut, del, seeds = [COUNTER_SEED], bump)]
pub counter: AccountInfo<'info>,
/// CHECK: Permission account for the counter PDA
#[account(
mut,
seeds = [PERMISSION_SEED, counter.key().as_ref()],
bump,
seeds::program = permission_program.key()
)]
pub permission: AccountInfo<'info>,
/// CHECK: Buffer for permission delegation
#[account(
mut,
seeds = [ephemeral_rollups_sdk::pda::DELEGATE_BUFFER_TAG, permission.key().as_ref()],
bump,
seeds::program = PERMISSION_PROGRAM_ID
)]
pub buffer_permission: AccountInfo<'info>,
/// CHECK: Delegation record for permission
#[account(
mut,
seeds = [ephemeral_rollups_sdk::pda::DELEGATION_RECORD_TAG, permission.key().as_ref()],
bump,
seeds::program = ephemeral_rollups_sdk::id()
)]
pub delegation_record_permission: AccountInfo<'info>,
/// CHECK: Delegation metadata for permission
#[account(
mut,
seeds = [ephemeral_rollups_sdk::pda::DELEGATION_METADATA_TAG, permission.key().as_ref()],
bump,
seeds::program = ephemeral_rollups_sdk::id()
)]
pub delegation_metadata_permission: AccountInfo<'info>,
/// CHECK: Permission Program
#[account(address = PERMISSION_PROGRAM_ID)]
pub permission_program: AccountInfo<'info>,
pub system_program: Program<'info, System>,
/// CHECK: Checked by the delegate program
pub validator: Option<AccountInfo<'info>>,
}
/// Undelegate context for the counter and its permission account.
/// `#[commit]` injects `magic_context` and `magic_program`.
#[commit]
#[derive(Accounts)]
pub struct UndelegateCounter<'info> {
#[account(mut)]
pub payer: Signer<'info>,
#[account(mut, seeds = [COUNTER_SEED], bump)]
pub counter: Account<'info, Counter>,
/// CHECK: Checked by the permission program
#[account(
mut,
seeds = [PERMISSION_SEED, counter.key().as_ref()],
bump,
seeds::program = permission_program.key()
)]
pub permission: AccountInfo<'info>,
/// CHECK: Permission Program
#[account(address = PERMISSION_PROGRAM_ID)]
pub permission_program: UncheckedAccount<'info>,
}
