@layerzerolabs/framework-solana-anchor-trait 0.2.62 → 0.2.64

package/examples/shapes/programs/ellipse/src/lib.rs

@@ -1,7 +1,4 @@
-pub mod state;
-
 use anchor_lang::prelude::*;
-use state::ShapeState;
 
 declare_id!("ELp1111111111111111111111111111111111111111");
 
@@ -28,12 +25,22 @@ pub struct GetName<'info> {
     pub shape: Account<'info, ShapeState>,
 }
 
-/// Full Override accounts — ellipse perimeter reads state differently.
+/// Custom accounts — ellipse perimeter reads state differently.
 #[derive(Accounts)]
 pub struct EllipseAccounts<'info> {
     pub shape: Account<'info, ShapeState>,
 }
 
+#[derive(Accounts)]
+pub struct GetDimension<'info> {
+    pub shape: Account<'info, ShapeState>,
+}
+
+#[derive(Accounts)]
+pub struct Clear<'info> {
+    #[account(mut)]
+    pub shape: Account<'info, ShapeState>,
+}
 // --- Param types ---
 
 #[derive(Clone, AnchorSerialize, AnchorDeserialize)]
@@ -45,18 +52,33 @@ pub struct InitParams {
 #[derive(Clone, AnchorSerialize, AnchorDeserialize)]
 pub struct ComputeParams {}
 
-// --- Program module ---
-// Required:  initialize, get_name
-// Handler Override:  compute_area (π*w*h/4)
-// Full Override:  compute_perimeter (custom EllipseAccounts)
-// Default:   get_dimension_count
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct ScaleParams {
+    pub factor: u64,
+}
+
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct DimensionParams {
+    pub index: u8,
+}
 
-#[shapes_macros::shapes(state = ShapeState)]
+// --- Program module ---
+// ShapeState — generated in prelude by #[shapes]
+//
+// Required:   initialize, get_name, get_dimension, clear
+// Override:   compute_area (reuses StdComputeArea, π*w*h/4)
+// Override:   compute_perimeter (custom EllipseAccounts)
+// Override:   reset (reuses StdReset, restores to unit circle: width=height=10)
+// Default:    scale, get_dimension_count
+
+#[shapes_macros::shapes]
 pub mod shapes_ellipse {
 
-    #[allow(unused_mut)]
     #[shapes_instruction]
-    pub fn initialize(mut ctx: Context<Initialize>, params: InitParams) -> Result<()> {
+    pub fn initialize(ctx: &mut Context<Initialize>, params: &InitParams) -> Result<()> {
+        // This is a dummy check to ensure the audit macro is working.
+        let _ = SHAPES_AUDIT_ENABLED;
+
         ctx.accounts.shape.width = params.width;
         ctx.accounts.shape.height = params.height;
         ctx.accounts.shape.bump = ctx.bumps.shape;
@@ -64,25 +86,55 @@ pub mod shapes_ellipse {
     }
 
     #[shapes_instruction]
-    pub fn get_name(_ctx: Context<GetName>) -> Result<String> {
+    pub fn get_name(_ctx: &Context<GetName>) -> Result<String> {
         Ok("Ellipse".to_string())
     }
 
-    // HANDLER OVERRIDE — reuses StdComputeArea accounts, ellipse formula.
     #[shapes_instruction]
-    pub fn compute_area(ctx: Context<StdComputeArea>, _params: ComputeParams) -> Result<u64> {
+    pub fn get_dimension(ctx: &Context<GetDimension>, params: &DimensionParams) -> Result<u64> {
+        let s = &ctx.accounts.shape;
+        match params.index {
+            0 => Ok(s.width),  // semi-axis a
+            1 => Ok(s.height), // semi-axis b
+            _ => err!(anchor_lang::error::ErrorCode::InvalidProgramId),
+        }
+    }
+
+    #[shapes_instruction]
+    pub fn clear(ctx: &mut Context<Clear>) -> Result<()> {
+        let s = &mut ctx.accounts.shape;
+        s.width = 0;
+        s.height = 0;
+        Ok(())
+    }
+
+    // OVERRIDE — reuses StdComputeArea accounts, ellipse formula.
+    #[shapes_instruction]
+    pub fn compute_area(ctx: &Context<StdComputeArea>, _params: &ComputeParams) -> Result<u64> {
         let s = &ctx.accounts.shape;
         // Ellipse area = π * a * b where a=w/2, b=h/2 → π * w * h / 4
         Ok(314_159 * s.width * s.height / 400_000)
     }
 
-    // FULL OVERRIDE — custom EllipseAccounts, ellipse perimeter approximation.
+    // OVERRIDE — custom EllipseAccounts, ellipse perimeter approximation.
     #[shapes_instruction]
-    pub fn compute_perimeter(ctx: Context<EllipseAccounts>, _params: ComputeParams) -> Result<u64> {
+    pub fn compute_perimeter(
+        ctx: &Context<EllipseAccounts>,
+        _params: &ComputeParams,
+    ) -> Result<u64> {
         let s = &ctx.accounts.shape;
         // Simple approximation: π * (w + h) / 2
         Ok(314_159 * (s.width + s.height) / 200_000)
     }
 
+    // OVERRIDE — reuses StdReset, ellipse resets to unit circle (equal axes).
+    #[shapes_instruction]
+    pub fn reset(ctx: &mut Context<StdReset>) -> Result<()> {
+        let s = &mut ctx.accounts.shape;
+        s.width = 10;
+        s.height = 10;
+        Ok(())
+    }
+
     // DEFAULT — get_dimension_count returns 2, correct for any 2D shape.
 }

package/examples/shapes/programs/ellipse/tests/ellipse/helpers.rs

@@ -0,0 +1,110 @@
+//! Shared test helpers: PDA derivation, account builders, fixtures, and instruction builders.
+
+use anchor_lang::{AnchorSerialize, Discriminator};
+use mollusk_svm::{program::keyed_account_for_system_program, Mollusk};
+use shapes_ellipse::{instruction as ix, DimensionParams, InitParams, ShapeState};
+use solana_account::Account;
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+// ── Program + PDA derivation ──────────────────────────────────────────────────
+
+/// Bridge anchor-lang Pubkey (solana-program 2.x) → solana-pubkey 4.x via bytes.
+pub fn program_id() -> Pubkey {
+    let mut bytes = [0u8; 32];
+    bytes.copy_from_slice(shapes_ellipse::ID.as_ref());
+    Pubkey::new_from_array(bytes)
+}
+
+/// Shape PDA: seeds = [b"shape"]
+pub fn shape_pda() -> (Pubkey, u8) {
+    Pubkey::find_program_address(&[b"shape"], &program_id())
+}
+
+pub fn mollusk() -> Mollusk {
+    // `anchor build` outputs .so relative to the Cargo workspace root.
+    // Walk up from the crate to find the nearest Cargo.lock (workspace root)
+    // which is where target/deploy/ lives.
+    let binary = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .find(|p| p.join("Cargo.lock").exists())
+        .expect("Cargo.lock not found — workspace root missing")
+        .join("target/deploy/shapes_ellipse");
+    Mollusk::new(&program_id(), binary.to_str().unwrap())
+}
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+pub fn payer_key() -> Pubkey {
+    Pubkey::new_from_array([0xAA; 32])
+}
+
+pub fn payer_account() -> Account {
+    Account::new(10_000_000, 0, &Pubkey::new_from_array([0u8; 32]))
+}
+
+pub fn sys_keyed() -> (Pubkey, Account) {
+    keyed_account_for_system_program()
+}
+
+// ── Serialization helpers ─────────────────────────────────────────────────────
+
+pub fn ix_data<T: AnchorSerialize>(discriminator: &[u8], params: T) -> Vec<u8> {
+    let mut d = discriminator.to_vec();
+    d.extend(params.try_to_vec().unwrap());
+    d
+}
+
+// ── Account data builders ─────────────────────────────────────────────────────
+
+pub fn shape_data(width: u64, height: u64, bump: u8) -> Vec<u8> {
+    let mut d = ShapeState::DISCRIMINATOR.to_vec();
+    d.extend_from_slice(&width.to_le_bytes());
+    d.extend_from_slice(&height.to_le_bytes());
+    d.push(bump);
+    d
+}
+
+pub fn shape_account(width: u64, height: u64, bump: u8) -> Account {
+    Account {
+        lamports: 1_000_000,
+        data: shape_data(width, height, bump),
+        owner: program_id(),
+        executable: false,
+        rent_epoch: u64::MAX,
+    }
+}
+
+// ── Error helpers ─────────────────────────────────────────────────────────────
+
+pub fn program_err(e: impl Into<u32>) -> ProgramError {
+    ProgramError::Custom(e.into())
+}
+
+// ── Instruction builders ──────────────────────────────────────────────────────
+
+/// `initialize` (Anchor `init` on shape PDA):
+///   0: payer, 1: shape, 2: system_program
+pub fn initialize_ix(payer: &Pubkey, shape: &Pubkey, width: u64, height: u64) -> Instruction {
+    let (sys, _) = sys_keyed();
+    Instruction {
+        program_id: program_id(),
+        accounts: vec![
+            AccountMeta::new(*payer, true),
+            AccountMeta::new(*shape, false),
+            AccountMeta::new_readonly(sys, false),
+        ],
+        data: ix_data(ix::Initialize::DISCRIMINATOR, InitParams { width, height }),
+    }
+}
+
+/// `get_dimension` (view):
+///   0: shape
+pub fn get_dimension_ix(shape: &Pubkey, index: u8) -> Instruction {
+    Instruction {
+        program_id: program_id(),
+        accounts: vec![AccountMeta::new_readonly(*shape, false)],
+        data: ix_data(ix::GetDimension::DISCRIMINATOR, DimensionParams { index }),
+    }
+}

package/examples/shapes/programs/ellipse/tests/ellipse/negative.rs

@@ -0,0 +1,49 @@
+use crate::helpers::*;
+use mollusk_svm::result::types::ProgramResult;
+use solana_program_error::ProgramError;
+
+// ── initialize ────────────────────────────────────────────────────────────────
+
+/// double-init: shape account already exists → `init` constraint rejects.
+#[test]
+fn test_initialize_fails_on_double_init() {
+    let mollusk = mollusk();
+    let payer = payer_key();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_instruction(
+        &initialize_ix(&payer, &shape_key, 10, 6),
+        &[
+            (payer, payer_account()),
+            // Supply pre-existing shape account → `init` must fail.
+            (shape_key, shape_account(10, 6, shape_bump)),
+            sys_keyed(),
+        ],
+    );
+
+    assert_eq!(
+        result.program_result,
+        ProgramResult::Failure(ProgramError::Custom(0)),
+        "double-init should fail with system AccountAlreadyInUse"
+    );
+}
+
+// ── get_dimension ─────────────────────────────────────────────────────────────
+
+/// index out of range (index = 2) → `InvalidProgramId`.
+#[test]
+fn test_get_dimension_fails_with_out_of_bounds_index() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_instruction(
+        &get_dimension_ix(&shape_key, 2),
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+    );
+
+    assert_eq!(
+        result.program_result,
+        ProgramResult::Failure(program_err(anchor_lang::error::ErrorCode::InvalidProgramId)),
+        "get_dimension should fail with InvalidProgramId for out-of-bounds index"
+    );
+}

package/examples/shapes/programs/ellipse/tests/ellipse/positive.rs

@@ -0,0 +1,231 @@
+use crate::helpers::*;
+use anchor_lang::Discriminator;
+use mollusk_svm::result::Check;
+use shapes_ellipse::{instruction as ix, ComputeParams, ScaleParams};
+use solana_account::Account;
+use solana_instruction::{AccountMeta, Instruction};
+
+// ── initialize ────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_initialize_creates_shape_with_correct_dimensions() {
+    let mollusk = mollusk();
+    let payer = payer_key();
+    let (shape_key, shape_bump) = shape_pda();
+
+    mollusk.process_and_validate_instruction(
+        &initialize_ix(&payer, &shape_key, 10, 6),
+        &[
+            (payer, payer_account()),
+            (shape_key, Account::default()),
+            sys_keyed(),
+        ],
+        &[
+            Check::success(),
+            Check::account(&shape_key)
+                .data(&shape_data(10, 6, shape_bump))
+                .build(),
+        ],
+    );
+}
+
+// ── get_name ──────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_get_name_returns_ellipse() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new_readonly(shape_key, false)],
+            data: ix::GetName::DISCRIMINATOR.to_vec(),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    // Borsh String: 4-byte LE length prefix + UTF-8 bytes
+    let ret = &result.return_data;
+    let len = u32::from_le_bytes(ret[..4].try_into().unwrap()) as usize;
+    assert_eq!(std::str::from_utf8(&ret[4..4 + len]).unwrap(), "Ellipse");
+}
+
+// ── get_dimension ─────────────────────────────────────────────────────────────
+
+#[test]
+fn test_get_dimension_returns_semi_axis_a_at_index_0() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &get_dimension_ix(&shape_key, 0),
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    assert_eq!(
+        u64::from_le_bytes(result.return_data[..8].try_into().unwrap()),
+        10
+    );
+}
+
+#[test]
+fn test_get_dimension_returns_semi_axis_b_at_index_1() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &get_dimension_ix(&shape_key, 1),
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    assert_eq!(
+        u64::from_le_bytes(result.return_data[..8].try_into().unwrap()),
+        6
+    );
+}
+
+// ── clear ─────────────────────────────────────────────────────────────────────
+
+#[test]
+fn test_clear_zeros_dimensions() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new(shape_key, false)],
+            data: ix::Clear::DISCRIMINATOR.to_vec(),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[
+            Check::success(),
+            Check::account(&shape_key)
+                .data(&shape_data(0, 0, shape_bump))
+                .build(),
+        ],
+    );
+}
+
+// ── compute_area ──────────────────────────────────────────────────────────────
+
+/// Ellipse override: π * w * h / 4 (StdComputeArea accounts, readonly shape).
+#[test]
+fn test_compute_area_uses_ellipse_formula() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new_readonly(shape_key, false)],
+            data: ix_data(ix::ComputeArea::DISCRIMINATOR, ComputeParams {}),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    // 314_159 * 10 * 6 / 400_000 = 47
+    assert_eq!(
+        u64::from_le_bytes(result.return_data[..8].try_into().unwrap()),
+        47
+    );
+}
+
+// ── compute_perimeter ─────────────────────────────────────────────────────────
+
+/// Ellipse override: π * (w + h) / 2 (custom EllipseAccounts).
+#[test]
+fn test_compute_perimeter_uses_ellipse_approximation() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new_readonly(shape_key, false)],
+            data: ix_data(ix::ComputePerimeter::DISCRIMINATOR, ComputeParams {}),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    // 314_159 * (10 + 6) / 200_000 = 25
+    assert_eq!(
+        u64::from_le_bytes(result.return_data[..8].try_into().unwrap()),
+        25
+    );
+}
+
+// ── scale ─────────────────────────────────────────────────────────────────────
+
+/// Default scale: both axes scaled equally.
+#[test]
+fn test_scale_default_scales_both_axes() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new(shape_key, false)],
+            data: ix_data(ix::Scale::DISCRIMINATOR, ScaleParams { factor: 2 }),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[
+            Check::success(),
+            Check::account(&shape_key)
+                .data(&shape_data(20, 12, shape_bump))
+                .build(),
+        ],
+    );
+}
+
+// ── reset ─────────────────────────────────────────────────────────────────────
+
+/// Ellipse override: resets to unit circle (width = height = 10).
+#[test]
+fn test_reset_restores_unit_circle() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new(shape_key, false)],
+            data: ix::Reset::DISCRIMINATOR.to_vec(),
+        },
+        &[(shape_key, shape_account(30, 5, shape_bump))],
+        &[
+            Check::success(),
+            Check::account(&shape_key)
+                .data(&shape_data(10, 10, shape_bump))
+                .build(),
+        ],
+    );
+}
+
+// ── get_dimension_count ───────────────────────────────────────────────────────
+
+/// Default: always returns 2 for any 2D shape.
+#[test]
+fn test_get_dimension_count_returns_2() {
+    let mollusk = mollusk();
+    let (shape_key, shape_bump) = shape_pda();
+
+    let result = mollusk.process_and_validate_instruction(
+        &Instruction {
+            program_id: program_id(),
+            accounts: vec![AccountMeta::new_readonly(shape_key, false)],
+            data: ix::GetDimensionCount::DISCRIMINATOR.to_vec(),
+        },
+        &[(shape_key, shape_account(10, 6, shape_bump))],
+        &[Check::success()],
+    );
+
+    assert_eq!(result.return_data[0], 2u8);
+}

package/examples/shapes/programs/ellipse/tests/ellipse.rs

@@ -0,0 +1,23 @@
+//! Mollusk BPF tests for the Ellipse shapes program.
+//!
+//! Positive tests (happy-path):
+//!   - `initialize`          — creates ShapeState with correct dimensions
+//!   - `get_name`            — view: returns "Ellipse"
+//!   - `get_dimension`       — view: returns semi-axis a (index 0) and b (index 1)
+//!   - `clear`               — zeros both dimensions
+//!   - `compute_area`        — override: π * w * h / 4 (StdComputeArea accounts)
+//!   - `compute_perimeter`   — override: π * (w + h) / 2 (custom EllipseAccounts)
+//!   - `scale`               — default: scales both axes equally
+//!   - `reset`               — override: restores to unit circle (width = height = 10)
+//!   - `get_dimension_count` — default: always returns 2
+//!
+//! Negative tests (rejection):
+//!   - `initialize`          — double-init rejected
+//!   - `get_dimension`       — out-of-bounds index rejected
+
+#[path = "ellipse/helpers.rs"]
+mod helpers;
+#[path = "ellipse/negative.rs"]
+mod negative;
+#[path = "ellipse/positive.rs"]
+mod positive;

package/examples/shapes/programs/triangle/Cargo.toml

@@ -28,3 +28,10 @@ unexpected_cfgs = { level = "allow", check-cfg = [
 [dependencies]
 anchor-lang = { workspace = true }
 shapes-macros = { workspace = true }
+
+[dev-dependencies]
+mollusk-svm = { workspace = true }
+solana-account = { workspace = true }
+solana-instruction = { workspace = true }
+solana-program-error = { workspace = true }
+solana-pubkey = { workspace = true }

package/examples/shapes/programs/triangle/src/lib.rs

@@ -1,7 +1,4 @@
-pub mod state;
-
 use anchor_lang::prelude::*;
-use state::ShapeState;
 
 declare_id!("Tri1111111111111111111111111111111111111111");
 
@@ -28,6 +25,17 @@ pub struct GetName<'info> {
     pub shape: Account<'info, ShapeState>,
 }
 
+#[derive(Accounts)]
+pub struct GetDimension<'info> {
+    pub shape: Account<'info, ShapeState>,
+}
+
+#[derive(Accounts)]
+pub struct Clear<'info> {
+    #[account(mut)]
+    pub shape: Account<'info, ShapeState>,
+}
+
 // --- Param types ---
 
 #[derive(Clone, AnchorSerialize, AnchorDeserialize)]
@@ -39,17 +47,30 @@ pub struct InitParams {
 #[derive(Clone, AnchorSerialize, AnchorDeserialize)]
 pub struct ComputeParams {}
 
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct ScaleParams {
+    pub factor: u64,
+}
+
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct DimensionParams {
+    pub index: u8,
+}
+
 // --- Program module ---
-// Required:  initialize, get_name
-// Handler Override:  compute_area (triangle formula), compute_perimeter (isoceles)
-// Default:   get_dimension_count
+// ShapeState — generated in prelude by #[shapes]
+//
+// Required:   initialize, get_name, get_dimension, clear
+// Override:   compute_area (EXTEND — adds verifier signer to default accounts)
+// Override:   compute_perimeter (reuses StdComputePerimeter, isoceles triangle)
+// Override:   scale (reuses StdScale, isoceles: only scale height)
+// Default:    reset, get_dimension_count
 
-#[shapes_macros::shapes(state = ShapeState)]
+#[shapes_macros::shapes]
 pub mod shapes_triangle {
 
     #[shapes_instruction]
-    #[allow(unused_mut)]
-    pub fn initialize(mut ctx: Context<Initialize>, params: InitParams) -> Result<()> {
+    pub fn initialize(ctx: &mut Context<Initialize>, params: &InitParams) -> Result<()> {
         ctx.accounts.shape.width = params.width;
         ctx.accounts.shape.height = params.height;
         ctx.accounts.shape.bump = ctx.bumps.shape;
@@ -57,27 +78,59 @@ pub mod shapes_triangle {
     }
 
     #[shapes_instruction]
-    pub fn get_name(_ctx: Context<GetName>) -> Result<String> {
+    pub fn get_name(_ctx: &Context<GetName>) -> Result<String> {
         Ok("Triangle".to_string())
     }
 
-    // HANDLER OVERRIDE — reuses StdComputeArea accounts, triangle formula.
     #[shapes_instruction]
-    pub fn compute_area(ctx: Context<StdComputeArea>, _params: ComputeParams) -> Result<u64> {
+    pub fn get_dimension(ctx: &Context<GetDimension>, params: &DimensionParams) -> Result<u64> {
+        let s = &ctx.accounts.shape;
+        match params.index {
+            0 => Ok(s.width),
+            1 => Ok(s.height),
+            _ => err!(anchor_lang::error::ErrorCode::InvalidProgramId),
+        }
+    }
+
+    #[shapes_instruction]
+    pub fn clear(ctx: &mut Context<Clear>) -> Result<()> {
+        let s = &mut ctx.accounts.shape;
+        s.width = 0;
+        s.height = 0;
+        Ok(())
+    }
+
+    #[shapes_instruction]
+    pub fn compute_area(ctx: &Context<ExtComputeArea>, _params: &ComputeParams) -> Result<u64> {
+        msg!("Verified by: {}", ctx.accounts.verifier.key());
         let s = &ctx.accounts.shape;
         Ok(s.width * s.height / 2)
     }
 
-    // HANDLER OVERRIDE — reuses StdComputePerimeter accounts, isoceles triangle.
+    // OVERRIDE — reuses StdComputePerimeter accounts, isoceles triangle.
     #[shapes_instruction]
     pub fn compute_perimeter(
-        ctx: Context<StdComputePerimeter>,
-        _params: ComputeParams,
+        ctx: &Context<StdComputePerimeter>,
+        _params: &ComputeParams,
     ) -> Result<u64> {
         let s = &ctx.accounts.shape;
-        // Isoceles: two equal sides (width) + base (height)
         Ok(s.width + s.width + s.height)
     }
 
+    // OVERRIDE — reuses StdScale accounts, isoceles: only scale height (base stays fixed).
+    #[shapes_instruction]
+    pub fn scale(ctx: &mut Context<StdScale>, params: &ScaleParams) -> Result<()> {
+        ctx.accounts.shape.height = ctx.accounts.shape.height.saturating_mul(params.factor);
+        Ok(())
+    }
+
     // DEFAULT — get_dimension_count returns 2, correct for any 2D shape.
+    // DEFAULT — reset sets width=1, height=1.
 }
+
+// EXTEND — extend StdComputeArea with a verifier signer, inside the module
+// so ExtComputeArea can reference ShapeState from the prelude.
+shapes_extend_accounts!(compute_area, ExtComputeArea, {
+    #[account(mut)]
+    pub verifier: Signer<'info>,
+});