add location support to device update functionality

update device location instruction for reference counter management

Author: juanolv

CHANGELOG.md

@@ -6,6 +6,8 @@ All notable changes to this project will be documented in this file.
 
 ### Breaking
 
+- Updated the device update command to allow modifying a device’s location.
+
 ### Changes
 
 ## [v0.6.11](https://github.com/malbeclabs/doublezero/compare/client/v0.6.10...client/v0.6.11) – 2025-11-13
@@ -59,6 +61,7 @@ All notable changes to this project will be documented in this file.
   - serviceability: prevent device interface name duplication
   - Update serviceability and telemetry program instruction args to use the `BorshDeserializeIncremental` derive macro incremental, backward-compatible, deserialization of structs.
   - Add explicit signer checks for payer accounts across various processors to improve security and ensure correct transaction authorization.
+    - Add the ability to update a Device’s location, managing the reference counters accordingly.
 - CLI
   - Removed `--bgp-community` option from `doublezero exchange create` since these values are now assigned automatically
   - Add `--next-bgp-community` option to `doublezero global-config set` so authorized users can control which bgp_community will be assigned next

smartcontract/cli/src/device/update.rs

@@ -35,6 +35,9 @@ pub struct UpdateDeviceCliCommand {
     /// Contributor Pubkey (optional)
     #[arg(long, value_parser = validate_pubkey)]
     pub contributor: Option<String>,
+    /// Location Pubkey (optional)
+    #[arg(long, value_parser = validate_pubkey)]
+    pub location: Option<String>,
     /// Management VRF name (optional)
     #[arg(long)]
     pub mgmt_vrf: Option<String>,
@@ -113,6 +116,10 @@ impl UpdateDeviceCliCommand {
             dz_prefixes: self.dz_prefixes,
             metrics_publisher,
             contributor_pk: contributor,
+            location_pk: match &self.location {
+                Some(location) => Some(Pubkey::from_str(location)?),
+                None => None,
+            },
             mgmt_vrf: self.mgmt_vrf,
             interfaces: None,
             max_users: self.max_users,
@@ -258,6 +265,9 @@ mod tests {
                 contributor_pk: Some(Pubkey::from_str_const(
                     "HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx",
                 )),
+                location_pk: Some(Pubkey::from_str_const(
+                    "HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx",
+                )),
                 mgmt_vrf: Some("default".to_string()),
                 interfaces: None,
                 max_users: Some(1025),
@@ -275,6 +285,7 @@ mod tests {
             dz_prefixes: Some("1.2.3.4/32".parse().unwrap()),
             metrics_publisher: Some("HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx".to_string()),
             contributor: Some("HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx".to_string()),
+            location: Some("HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx".to_string()),
             mgmt_vrf: Some("default".to_string()),
             max_users: Some(1025),
             users_count: Some(0),
@@ -364,6 +375,7 @@ mod tests {
             public_ip: None,
             dz_prefixes: None,
             metrics_publisher: None,
+            location: None,
             contributor: None,
             mgmt_vrf: None,
             max_users: Some(255),
@@ -453,6 +465,7 @@ mod tests {
             public_ip: Some([10, 20, 30, 40].into()),
             dz_prefixes: None,
             metrics_publisher: None,
+            location: None,
             contributor: None,
             mgmt_vrf: None,
             max_users: None,

smartcontract/programs/doublezero-serviceability/src/error.rs

@@ -121,6 +121,8 @@ pub enum DoubleZeroError {
     InvalidInterfaceType, // variant 57
     #[error("Invalid Loopback Type")]
     InvalidLoopbackType, // variant 58
+    #[error("Invalid Actual Location")]
+    InvalidActualLocation, // variant 59
 }
 
 impl From<DoubleZeroError> for ProgramError {
@@ -185,6 +187,7 @@ impl From<DoubleZeroError> for ProgramError {
             DoubleZeroError::InterfaceAlreadyExists => ProgramError::Custom(56),
             DoubleZeroError::InvalidInterfaceType => ProgramError::Custom(57),
             DoubleZeroError::InvalidLoopbackType => ProgramError::Custom(58),
+            DoubleZeroError::InvalidActualLocation => ProgramError::Custom(59),
         }
     }
 }
@@ -250,6 +253,7 @@ impl From<u32> for DoubleZeroError {
             56 => DoubleZeroError::InterfaceAlreadyExists,
             57 => DoubleZeroError::InvalidInterfaceType,
             58 => DoubleZeroError::InvalidLoopbackType,
+            59 => DoubleZeroError::InvalidActualLocation,
             _ => DoubleZeroError::Custom(e),
         }
     }
@@ -335,6 +339,7 @@ mod tests {
             InterfaceAlreadyExists,
             InvalidInterfaceType,
             InvalidLoopbackType,
+            InvalidActualLocation,
         ];
         for err in variants {
             let pe: ProgramError = err.clone().into();

smartcontract/programs/doublezero-serviceability/src/processors/device/update.rs

@@ -2,17 +2,16 @@ use crate::{
     error::DoubleZeroError,
     globalstate::globalstate_get,
     helper::*,
-    state::{accounttype::AccountType, contributor::Contributor, device::*},
+    state::{accounttype::AccountType, contributor::Contributor, device::*, location::Location},
 };
 use borsh::BorshSerialize;
 use borsh_incremental::BorshDeserializeIncremental;
 use core::fmt;
 use doublezero_program_common::{types::NetworkV4List, validate_account_code};
-#[cfg(test)]
-use solana_program::msg;
 use solana_program::{
     account_info::{next_account_info, AccountInfo},
     entrypoint::ProgramResult,
+    msg,
     pubkey::Pubkey,
 };
 
@@ -71,6 +70,17 @@ pub fn process_update_device(
 
     let device_account = next_account_info(accounts_iter)?;
     let contributor_account = next_account_info(accounts_iter)?;
+    // Update location accounts (old and new)
+
+    let (location_old_account, location_new_account) = if accounts.len() == 7 {
+        (
+            Some(next_account_info(accounts_iter)?),
+            Some(next_account_info(accounts_iter)?),
+        )
+    } else {
+        (None, None)
+    };
+
     let globalstate_account = next_account_info(accounts_iter)?;
     let payer_account = next_account_info(accounts_iter)?;
     let system_program = next_account_info(accounts_iter)?;
@@ -148,6 +158,43 @@ pub fn process_update_device(
         device.max_users = max_users;
     }
 
+    // Handle location update if both old and new location accounts are provided
+    if let (Some(location_old_account), Some(location_new_account)) =
+        (location_old_account, location_new_account)
+    {
+        if location_old_account.key != location_new_account.key {
+            let mut location_old = Location::try_from(location_old_account)?;
+            let mut location_new = Location::try_from(location_new_account)?;
+            if device.location_pk != *location_old_account.key {
+                msg!(
+                    "Invalid location account. Device location_pk: {}, location_old_account: {}",
+                    device.location_pk,
+                    location_old_account.key
+                );
+                return Err(DoubleZeroError::InvalidActualLocation.into());
+            }
+
+            location_old.reference_count = location_old.reference_count.saturating_sub(1);
+            location_new.reference_count = location_new.reference_count.saturating_add(1);
+
+            // Set new location pk in device
+            device.location_pk = *location_new_account.key;
+
+            account_write(
+                location_old_account,
+                &location_old,
+                payer_account,
+                system_program,
+            )?;
+            account_write(
+                location_new_account,
+                &location_new,
+                payer_account,
+                system_program,
+            )?;
+        }
+    }
+
     account_write(device_account, &device, payer_account, system_program)?;
 
     #[cfg(test)]

smartcontract/programs/doublezero-serviceability/tests/device_test.rs

@@ -208,6 +208,8 @@ async fn test_device() {
         vec![
             AccountMeta::new(device_pubkey, false),
             AccountMeta::new(contributor_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
             AccountMeta::new(globalstate_pubkey, false),
         ],
         &payer,
@@ -340,6 +342,8 @@ async fn test_device() {
         vec![
             AccountMeta::new(device_pubkey, false),
             AccountMeta::new(contributor_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
             AccountMeta::new(globalstate_pubkey, false),
         ],
         &payer,
@@ -492,6 +496,8 @@ async fn test_device_update_metrics_publisher_by_foundation_allowlist_account()
         vec![
             AccountMeta::new(device_pubkey, false),
             AccountMeta::new(contributor_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
             AccountMeta::new(globalstate_pubkey, false),
         ],
         &payer,
@@ -525,6 +531,8 @@ async fn test_device_update_metrics_publisher_by_foundation_allowlist_account()
         vec![
             AccountMeta::new(device_pubkey, false),
             AccountMeta::new(contributor_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
+            AccountMeta::new(location_pubkey, false),
             AccountMeta::new(globalstate_pubkey, false),
         ],
         &payer,