WIP: Oracle with Kamino Scope Aggregator

interface/src/lib.rs

@@ -21,11 +21,12 @@ use swig::actions::{
 pub use swig_compact_instructions::*;
 use swig_state::{
     action::{
-        all::All, manage_authority::ManageAuthority, program::Program, program_all::ProgramAll,
-        program_curated::ProgramCurated, program_scope::ProgramScope, sol_limit::SolLimit,
-        sol_recurring_limit::SolRecurringLimit, stake_all::StakeAll, stake_limit::StakeLimit,
-        stake_recurring_limit::StakeRecurringLimit, sub_account::SubAccount,
-        token_limit::TokenLimit, token_recurring_limit::TokenRecurringLimit, Action, Permission,
+        all::All, manage_authority::ManageAuthority, oracle_limits::OracleTokenLimit,
+        program::Program, program_all::ProgramAll, program_curated::ProgramCurated,
+        program_scope::ProgramScope, sol_limit::SolLimit, sol_recurring_limit::SolRecurringLimit,
+        stake_all::StakeAll, stake_limit::StakeLimit, stake_recurring_limit::StakeRecurringLimit,
+        sub_account::SubAccount, token_limit::TokenLimit,
+        token_recurring_limit::TokenRecurringLimit, Action, Permission,
     },
     authority::{
         secp256k1::{hex_encode, AccountsPayload},
@@ -50,6 +51,7 @@ pub enum ClientAction {
     StakeLimit(StakeLimit),
     StakeRecurringLimit(StakeRecurringLimit),
     StakeAll(StakeAll),
+    OracleTokenLimit(OracleTokenLimit),
 }
 
 impl ClientAction {
@@ -75,6 +77,9 @@ impl ClientAction {
                 (Permission::StakeRecurringLimit, StakeRecurringLimit::LEN)
             },
             ClientAction::StakeAll(_) => (Permission::StakeAll, StakeAll::LEN),
+            ClientAction::OracleTokenLimit(_) => {
+                (Permission::OracleTokenLimit, OracleTokenLimit::LEN)
+            },
         };
         let offset = data.len() as u32;
         let header = Action::new(
@@ -101,6 +106,7 @@ impl ClientAction {
             ClientAction::StakeLimit(action) => action.into_bytes(),
             ClientAction::StakeRecurringLimit(action) => action.into_bytes(),
             ClientAction::StakeAll(action) => action.into_bytes(),
+            ClientAction::OracleTokenLimit(action) => action.into_bytes(),
         };
         data.extend_from_slice(
             bytes_res.map_err(|e| anyhow::anyhow!("Failed to serialize action {:?}", e))?,

program/Cargo.toml

@@ -27,6 +27,8 @@ bytemuck = { version = "1.13.1", features = ["derive"] }
 no-padding = { path = "../no-padding" }
 solana-security-txt = "=1.1.1"
 default-env = "=0.1.1"
+oracle-mapping-state = { git = "https://github.com/anagrambuild/scope-oracle-mapper", branch = "santhosh/state-crate" }
+
 
 [dev-dependencies]
 solana-sdk = "2"
@@ -47,6 +49,7 @@ solana-client = "=2.2.4"
 solana-program = "=2.2.1"
 once_cell = "1.21.3"
 spl-memo = "=6.0.0"
+base64 = "0.22.1"
 solana-secp256r1-program = "2.2.1"
 openssl = { version = "0.10.72", features = ["vendored"] }
 hex = "0.4.3"

program/src/actions/sign_v1.rs

@@ -13,12 +13,13 @@ use pinocchio::{
     sysvars::{clock::Clock, Sysvar},
     ProgramResult,
 };
-use pinocchio_pubkey::from_str;
+use pinocchio_pubkey::{from_str, pubkey};
 use swig_assertions::*;
 use swig_compact_instructions::InstructionIterator;
 use swig_state::{
     action::{
         all::All,
+        oracle_limits::OracleTokenLimit,
         program::Program,
         program_all::ProgramAll,
         program_curated::ProgramCurated,
@@ -43,7 +44,7 @@ use crate::{
         accounts::{Context, SignV1Accounts},
         SwigInstruction,
     },
-    util::{build_restricted_keys, hash_except},
+    util::{build_restricted_keys, calculate_token_value, get_price_data, hash_except},
     AccountClassification,
 };
 // use swig_instructions::InstructionIterator;
@@ -361,7 +362,56 @@ pub fn sign_v1(
                     }
                     if lamports > &current_lamports {
                         let amount_diff = lamports - current_lamports;
+                        {
+                            if let Some(action) =
+                                RoleMut::get_action_mut::<OracleTokenLimit>(actions, &[0u8])?
+                            {
+                                let scope_data = unsafe {
+                                    let scope_account =
+                                        &all_accounts.get_unchecked(all_accounts.len() - 1);
+                                    // also check if owner matches
+                                    if scope_account.owner().as_ref()
+                                        != &pubkey!("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ")
+                                    {
+                                        return Err(SwigError::WrongOracleProgramAccount.into());
+                                    }
+                                    scope_account.borrow_data_unchecked()
+                                };
 
+                                let mapping_registry = unsafe {
+                                    let mapping_account =
+                                        &all_accounts.get_unchecked(all_accounts.len() - 2);
+                                    if mapping_account.owner().as_ref()
+                                        != &pubkey!("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ")
+                                    {
+                                        return Err(SwigError::WrongOracleMappingAccount.into());
+                                    }
+                                    mapping_account.borrow_data_unchecked()
+                                };
+
+                                let (price, exp, mint_decimal) = get_price_data(
+                                    mapping_registry,
+                                    scope_data,
+                                    &pubkey!("So11111111111111111111111111111111111111112"),
+                                    &clock,
+                                )?;
+
+                                let token_value_in_base = calculate_token_value(
+                                    price,
+                                    exp,
+                                    action.get_base_asset_decimals(),
+                                    amount_diff,
+                                    mint_decimal,
+                                    action.get_base_asset_decimals(),
+                                )?;
+
+                                action.run_for_sol(token_value_in_base)?;
+
+                                if !action.passthrough_check {
+                                    continue;
+                                }
+                            };
+                        }
                         {
                             if let Some(action) = RoleMut::get_action_mut::<SolLimit>(actions, &[])?
                             {
@@ -421,6 +471,45 @@ pub fn sign_v1(
 
                     if balance > &current_token_balance {
                         let diff = balance - current_token_balance;
+                        // Check oracle token limit
+                        {
+                            if let Some(action) =
+                                RoleMut::get_action_mut::<OracleTokenLimit>(actions, &[0u8])?
+                            {
+                                let scope_data = unsafe {
+                                    &all_accounts
+                                        .get_unchecked(all_accounts.len() - 1)
+                                        .borrow_data_unchecked()
+                                };
+
+                                let mapping_data = unsafe {
+                                    &all_accounts
+                                        .get_unchecked(all_accounts.len() - 2)
+                                        .borrow_data_unchecked()
+                                };
+
+                                let mint_bytes =
+                                    mint.try_into().map_err(|_| SwigError::OracleMintNotFound)?;
+
+                                let (price, exp, mint_decimal) =
+                                    get_price_data(mapping_data, scope_data, &mint_bytes, &clock)?;
+
+                                let token_value_in_base = calculate_token_value(
+                                    price,
+                                    exp,
+                                    action.get_base_asset_decimals(),
+                                    diff,
+                                    mint_decimal,
+                                    action.get_base_asset_decimals(),
+                                )?;
+
+                                action.run_for_token(token_value_in_base)?;
+
+                                if !action.passthrough_check {
+                                    continue;
+                                }
+                            };
+                        }
                         {
                             if let Some(action) =
                                 RoleMut::get_action_mut::<TokenRecurringLimit>(actions, mint)?

program/src/error.rs

@@ -112,6 +112,42 @@ pub enum SwigError {
     AccountDataModifiedUnexpectedly,
     /// Cannot update root authority (ID 0)
     PermissionDeniedCannotUpdateRootAuthority,
+    /// Oracle account required for token limit check was not found
+    PermissionDeniedMissingOracleAccount,
+    /// Failed to read oracle price data
+    InvalidOraclePriceData,
+    /// Failed to verify the oracle level to FULL
+    OracleVerficationLevelFailed,
+    /// Failed to fetch latest oracle price
+    OraclePriceTooOld,
+    /// Wrong oracle program account
+    WrongOracleProgramAccount,
+    /// Wrong oracle mapping account
+    WrongOracleMappingAccount,
+    /// Oracle mint not found
+    OracleMintNotFound,
+    /// Oracle value overflow during calculation
+    OracleValueOverflow,
+    /// Oracle invalid price chain configuration
+    OracleInvalidPriceChain,
+    /// Oracle data bounds error
+    OracleDataBoundsError,
+    /// Oracle empty price chain
+    OracleEmptyPriceChain,
+    /// Oracle multiplication overflow
+    OracleMultiplicationOverflow,
+    /// Oracle addition overflow
+    OracleAdditionOverflow,
+    /// Oracle subtraction overflow
+    OracleSubtractionOverflow,
+    /// Oracle exponent mismatch between price sources
+    OracleExponentMismatch,
+    /// Oracle price difference exceeds threshold
+    OraclePriceDifferenceExceedsThreshold,
+    /// Oracle mapping registry is not initialized
+    OracleMappingRegistryNotInitialized,
+    /// Oracle price chain empty
+    OraclePriceChainEmpty,
 }
 
 /// Implements conversion from SwigError to ProgramError.