WIP: Oracle with Kamino Scope Aggregator

cli/dumps/mapping.json

@@ -0,0 +1,14 @@
+{
+  "pubkey": "FbeuRDWwLvZWEU3HNtaLoYKagw9rH1NvmjpRMpjMwhDw",
+  "account": {
+    "lamports": 1468560,
+    "data": [
+      "ASgQWPWCd2TeA+fvXK6Z2qNd9rPpSvLyfN/8IrV2xhjoAAEACQApAP4ABpuIV/6rgYT7aH9jRhjANdrEOdwa6ztVmKDwAAAAAAEpAQkAAP////8=",
+      "base64"
+    ],
+    "owner": "9WM51wrB9xpRzFgYJHocYNnx4DF6G6ee2eB44ZGoZ8vg",
+    "executable": false,
+    "rentEpoch": 18446744073709551615,
+    "space": 83
+  }
+}

cli/src/commands.rs

@@ -239,6 +239,45 @@ pub fn parse_permission_from_json(permission_json: &Value) -> Result<Permission>
                 recurring,
             })
         },
+        Some("oracle") => {
+            // Oracle value-based limit, optional recurring
+            // Supported fields:
+            // - baseAsset: "USD" | "EUR" (preferred) OR baseAssetType: number (u8)
+            // - valueLimit: u64
+            // - passthrough: bool (default false)
+            // - recurring: { window: u64 } (optional)
+            let base_asset_type = if let Some(base_str) = permission_json["baseAsset"].as_str() {
+                match base_str {
+                    "USD" | "usd" => 0u8,
+                    "EUR" | "eur" => 1u8,
+                    other => return Err(anyhow!("Invalid baseAsset: {} (use USD or EUR)", other)),
+                }
+            } else {
+                permission_json["baseAssetType"].as_u64().unwrap_or(0) as u8
+            };
+
+            let value_limit = permission_json["valueLimit"].as_u64().ok_or_else(|| {
+                anyhow!("valueLimit is required for oracle permission (u64 in base asset units)")
+            })?;
+
+            let passthrough_check = permission_json["passthrough"].as_bool().unwrap_or(false);
+
+            let recurring = if let Some(recurring) = permission_json.get("recurring") {
+                let window = recurring["window"].as_u64().ok_or_else(|| {
+                    anyhow!("recurring.window is required when recurring is provided")
+                })?;
+                Some(swig_sdk::RecurringConfig::new(window))
+            } else {
+                None
+            };
+
+            Ok(Permission::OracleLimit {
+                base_asset_type,
+                value_limit,
+                passthrough_check,
+                recurring,
+            })
+        },
         Some(unknown) => Err(anyhow!("Invalid permission type: {}", unknown)),
         None => Err(anyhow!("Permission type is required")),
     }
@@ -883,6 +922,12 @@ pub fn run_command_mode(ctx: &mut SwigCliContext, cmd: Command) -> Result<()> {
                                 amount: 0,
                                 recurring: None,
                             }),
+                            "OracleLimit" | "Oracle" => Ok(Permission::OracleLimit {
+                                base_asset_type: 0,
+                                value_limit: 0,
+                                passthrough_check: false,
+                                recurring: None,
+                            }),
                             "Program" => Ok(Permission::Program {
                                 program_id: Pubkey::default(),
                             }),

cli/src/interactive.rs

@@ -763,10 +763,11 @@ fn switch_authority_interactive(ctx: &mut SwigCliContext) -> Result<()> {
     // Store the authority keypair in the context
     ctx.authority = Some(authority.insecure_clone());
 
+    let authority_static: &Keypair = Box::leak(Box::new(authority.insecure_clone()));
     ctx.wallet
         .as_mut()
         .unwrap()
-        .switch_authority(role_id, client_role, None)?;
+        .switch_authority(role_id, client_role, Some(authority_static))?;
     Ok(())
 }
 
@@ -794,7 +795,7 @@ fn transfer_interactive(ctx: &mut SwigCliContext) -> Result<()> {
         .interact_text()?;
 
     let transfer_instruction = transfer(
-        &ctx.wallet.as_ref().unwrap().get_swig_account()?,
+        &ctx.wallet.as_ref().unwrap().get_swig_wallet_address()?,
         &Pubkey::from_str(&recipient)?,
         amount,
     );
@@ -803,7 +804,7 @@ fn transfer_interactive(ctx: &mut SwigCliContext) -> Result<()> {
         .wallet
         .as_mut()
         .unwrap()
-        .sign(vec![transfer_instruction], None)?;
+        .sign_v2(vec![transfer_instruction], None)?;
 
     println!("Signature: {}", signature);
 
@@ -855,6 +856,7 @@ pub fn get_permissions_interactive() -> Result<Vec<Permission>> {
         "Sub Account (Sub-account management)",
         "Stake (Stake management permissions)",
         "Stake All (All stake management permissions)",
+        "Oracle (Value-based limit using price oracle)",
     ];
 
     let mut permissions = Vec::new();
@@ -1069,6 +1071,53 @@ pub fn get_permissions_interactive() -> Result<Vec<Permission>> {
                 recurring: None,
             },
             13 => Permission::StakeAll,
+            14 => {
+                // Oracle value-based limit
+                // Choose base asset
+                let base_assets = vec!["USD (6 decimals)", "EUR (6 decimals)"];
+                let base_idx = Select::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Choose base asset for oracle limit")
+                    .items(&base_assets)
+                    .default(0)
+                    .interact()?;
+                let base_asset_type: u8 = match base_idx {
+                    0 => 0,
+                    1 => 1,
+                    _ => 0,
+                };
+
+                // Value limit in base asset minor units (e.g., 6 decimals for USD)
+                let value_limit: u64 = Input::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Enter value limit in base asset minor units (e.g., 100_000_000 for 100.000000)")
+                    .interact_text()?;
+
+                let passthrough_check = Confirm::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Enable passthrough check (continue checking other actions)?")
+                    .default(false)
+                    .interact()?;
+
+                // Recurring?
+                let is_recurring = Confirm::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Make this a recurring oracle limit?")
+                    .default(false)
+                    .interact()?;
+
+                let recurring = if is_recurring {
+                    let window: u64 = Input::with_theme(&ColorfulTheme::default())
+                        .with_prompt("Enter time window in slots")
+                        .interact_text()?;
+                    Some(RecurringConfig::new(window))
+                } else {
+                    None
+                };
+
+                Permission::OracleLimit {
+                    base_asset_type,
+                    value_limit,
+                    passthrough_check,
+                    recurring,
+                }
+            },
             _ => unreachable!(),
         };