fix: track each user's access pass

Author: martinsander00

client/doublezero/src/main.rs

@@ -56,9 +56,16 @@ impl<C: CliCommand + Sync> doublezero_daemon_cli::LedgerClient for LedgerAdapter
             .list_user(doublezero_sdk::commands::user::list::ListUserCommand)
     }
 
-    fn delete_user(&self, pubkey: solana_sdk::pubkey::Pubkey) -> eyre::Result<()> {
+    fn delete_user(
+        &self,
+        pubkey: solana_sdk::pubkey::Pubkey,
+        accesspass_pk: Option<solana_sdk::pubkey::Pubkey>,
+    ) -> eyre::Result<()> {
         self.client
-            .delete_user(doublezero_sdk::commands::user::delete::DeleteUserCommand { pubkey })?;
+            .delete_user(doublezero_sdk::commands::user::delete::DeleteUserCommand {
+                pubkey,
+                accesspass_pk,
+            })?;
         Ok(())
     }
 

crates/doublezero-daemon-cli/src/disconnect.rs

@@ -46,6 +46,9 @@ pub struct Disconnect {
     /// traffic may still route over DoubleZero briefly after this returns.
     #[arg(long, default_value_t = false)]
     pub no_wait: bool,
+    /// Access pass for a legacy user that matches multiple passes
+    #[arg(long)]
+    pub access_pass: Option<Pubkey>,
     #[arg(value_enum)]
     pub dz_mode: Option<DzMode>,
 }
@@ -167,7 +170,7 @@ impl Disconnect {
 
             spinner.inc(1);
             writeln!(out, "⚡  Removing account: {pubkey}")?;
-            match ledger.delete_user(*pubkey) {
+            match ledger.delete_user(*pubkey, self.access_pass) {
                 Ok(_) => {
                     writeln!(out, "    Account deletion submitted")?;
                 }
@@ -289,6 +292,7 @@ mod tests {
             client_ip: None,
             verbose: false,
             no_wait: false,
+            access_pass: None,
             dz_mode: None,
         }
     }
@@ -486,6 +490,7 @@ mod tests {
         let mut ledger = MockLedgerClient::new();
         let payer = Pubkey::new_unique();
         let feed_authority = Pubkey::new_unique();
+        let accesspass_pk = Pubkey::new_unique();
         let ip = Ipv4Addr::new(10, 0, 0, 1);
 
         let user_pk = Pubkey::new_unique();
@@ -501,14 +506,21 @@ mod tests {
         // delete_user SHOULD be called for self-owned user.
         ledger
             .expect_delete_user()
+            .with(
+                mockall::predicate::eq(user_pk),
+                mockall::predicate::eq(Some(accesspass_pk)),
+            )
             .once()
-            .returning(|_| Err(eyre::eyre!("simulated not found")));
+            .returning(|_, _| Err(eyre::eyre!("simulated not found")));
         // get_user for poll_for_user_closed — return "not found" immediately.
         ledger
             .expect_get_user()
             .returning(|_| Err(eyre::eyre!("User not found")));
 
-        let cmd = test_cmd();
+        let cmd = Disconnect {
+            access_pass: Some(accesspass_pk),
+            ..test_cmd()
+        };
         let spinner = hidden_spinner();
         let mut out = Vec::new();
         let result = cmd.delete_users(&ledger, ip, feed_authority, &spinner, &mut out);
@@ -577,7 +589,7 @@ mod tests {
         ledger
             .expect_delete_user()
             .once()
-            .returning(|_| Err(eyre::eyre!("simulated not found")));
+            .returning(|_, _| Err(eyre::eyre!("simulated not found")));
         ledger
             .expect_get_user()
             .returning(|_| Err(eyre::eyre!("User not found")));
@@ -634,7 +646,7 @@ mod tests {
             ledger
                 .expect_list_user()
                 .returning(move || Ok(users.clone()));
-            ledger.expect_delete_user().once().returning(|_| Ok(()));
+            ledger.expect_delete_user().once().returning(|_, _| Ok(()));
             ledger
                 .expect_get_user()
                 .returning(|_| Err(eyre::eyre!("User not found")));

crates/doublezero-daemon-cli/src/ledger.rs

@@ -48,7 +48,7 @@ pub trait LedgerClient: Send + Sync {
     fn list_user(&self) -> eyre::Result<HashMap<Pubkey, User>>;
 
     /// Delete the user account at `pubkey`.
-    fn delete_user(&self, pubkey: Pubkey) -> eyre::Result<()>;
+    fn delete_user(&self, pubkey: Pubkey, accesspass_pk: Option<Pubkey>) -> eyre::Result<()>;
 
     /// Fetch the user account at `pubkey` (used to poll for deletion).
     fn get_user(&self, pubkey: Pubkey) -> eyre::Result<User>;

sdk/serviceability/python/serviceability/state.py

@@ -876,6 +876,7 @@ class User:
     # EdgeSeat Feeds whose per-feed seats this user consumed at connect (empty if none). Occupies
     # the former scalar feed_pk slot, which was never written with a real feed on any cluster.
     feed_pks: list[Pubkey] = field(default_factory=list)
+    access_pass_pub_key: Pubkey = Pubkey.default()
 
     @classmethod
     def from_bytes(cls, data: bytes) -> User:
@@ -909,6 +910,7 @@ def from_bytes(cls, data: bytes) -> User:
         # which read as an empty vec with the leftover zero bytes ignored as trailing data.
         # _read_pubkey_vec returns [] on EOF, so accounts predating the slot default to empty too.
         u.feed_pks = _read_pubkey_vec(r)
+        u.access_pass_pub_key = _read_pubkey(r)
         return u
 
 

sdk/serviceability/python/serviceability/tests/test_fixtures.py

@@ -371,29 +371,32 @@ def test_deserialize(self):
         assert len(u.feed_pks) == feed_pks_len
         for i in range(feed_pks_len):
             assert u.feed_pks[i] == Pubkey.from_string(fields[f"FeedPks{i}"])
+        assert u.access_pass_pub_key == Pubkey.from_string(fields["AccessPassPk"])
 
     def test_backward_compat_old_layout(self):
         # Deserializing an account binary that predates the BGP fields must
         # return zero values for those fields rather than failing.
         data, _ = _load_fixture("user")
         # Remove feed_pks (4 + 2*32 = 68) + bgp_rtt_ns (8) + last_bgp_reported_at (8)
-        # + last_bgp_up_at (8) + bgp_status (1) = 93 bytes.
-        truncated = data[:-93]
+        # + last_bgp_up_at (8) + bgp_status (1) + accesspass_pk (32) = 125 bytes.
+        truncated = data[:-125]
         u = User.from_bytes(truncated)
         assert u.bgp_status == BGPStatus.UNKNOWN
         assert u.last_bgp_up_at == 0
         assert u.last_bgp_reported_at == 0
         assert u.bgp_rtt_ns == 0
         assert u.feed_pks == []
+        assert u.access_pass_pub_key == Pubkey.default()
 
     def test_old_layout_zero_feed_slot_reads_as_empty_vec(self):
         # An account written by the previous layout carries a 32-zero-byte scalar
         # feed_pk slot where feed_pks now lives (never written with a real feed on
         # any cluster). It must read as an empty list, trailing zeros ignored.
         data, _ = _load_fixture("user")
-        old = data[:-68] + bytes(32)  # replace feed_pks (4 + 2*32) with the old slot
+        old = data[:-100] + bytes(32)
         u = User.from_bytes(old)
         assert u.feed_pks == []
+        assert u.access_pass_pub_key == Pubkey.default()
 
 
 class TestFixtureMulticastGroup:

sdk/serviceability/testdata/fixtures/generate-fixtures/src/main.rs

@@ -1128,6 +1128,7 @@ fn generate_user(dir: &Path) {
     let validator_pubkey = pubkey_from_byte(0x65);
     let feed_pk_a = pubkey_from_byte(0x67);
     let feed_pk_b = pubkey_from_byte(0x68);
+    let accesspass_pk = pubkey_from_byte(0x69);
 
     let val = User {
         account_type: AccountType::User,
@@ -1153,6 +1154,7 @@ fn generate_user(dir: &Path) {
         last_bgp_reported_at: 1_700_000_100,
         bgp_rtt_ns: 5_500_000,
         feed_pks: vec![feed_pk_a, feed_pk_b],
+        accesspass_pk,
     };
 
     let data = borsh::to_vec(&val).unwrap();
@@ -1188,6 +1190,7 @@ fn generate_user(dir: &Path) {
             FieldValue { name: "FeedPksLen".into(), value: "2".into(), typ: "u32".into() },
             FieldValue { name: "FeedPks0".into(), value: pubkey_bs58(&feed_pk_a), typ: "pubkey".into() },
             FieldValue { name: "FeedPks1".into(), value: pubkey_bs58(&feed_pk_b), typ: "pubkey".into() },
+            FieldValue { name: "AccessPassPk".into(), value: pubkey_bs58(&accesspass_pk), typ: "pubkey".into() },
         ],
     };
 

sdk/serviceability/testdata/fixtures/user.bin

@@ -136,6 +136,11 @@
       "name": "FeedPks1",
       "value": "7zyQEWTmwxVFUwWKuUhS7NWmv1mARobHjD5MMHGVxfks",
       "typ": "pubkey"
+    },
+    {
+      "name": "AccessPassPk",
+      "value": "84sot1BrqnyxtddJQyxt1JG1B2Kw8khCK5PErUaVgURD",
+      "typ": "pubkey"
     }
   ]
 }

sdk/serviceability/testdata/fixtures/user.json

@@ -866,6 +866,7 @@ export interface User {
    * the former scalar feedPk slot, which was never written with a real feed on any cluster.
    */
   feedPks: PublicKey[];
+  accessPassPubKey: PublicKey;
 }
 
 export function deserializeUser(data: Uint8Array): User {
@@ -899,6 +900,7 @@ export function deserializeUser(data: Uint8Array): User {
     // read as an empty vec with the leftover zero bytes ignored as trailing data. readPubkeyVec
     // returns [] on EOF, so accounts predating the slot default to empty too.
     feedPks: readPubkeyVec(r),
+    accessPassPubKey: readPubkey(r),
   };
 }
 

sdk/serviceability/typescript/serviceability/state.ts

@@ -408,28 +408,33 @@ describe("User fixture", () => {
       expect(expected).toBeDefined();
       expect(u.feedPks[i].toBase58()).toBe(expected!);
     }
+    expect(u.accessPassPubKey.toBase58()).toBe(
+      meta.fields.find((f) => f.name === "AccessPassPk")?.value,
+    );
   });
 
   test("backward compat: old layout yields zero for new fields", () => {
     const [data] = loadFixture("user");
     // Remove feed_pks (4 + 2*32 = 68) + bgp_rtt_ns (8) + last_bgp_reported_at (8)
-    // + last_bgp_up_at (8) + bgp_status (1) = 93 bytes
-    const truncated = data.slice(0, data.length - 93);
+    // + last_bgp_up_at (8) + bgp_status (1) + accesspass_pk (32) = 125 bytes
+    const truncated = data.slice(0, data.length - 125);
     const u = deserializeUser(truncated);
     expect(u.bgpStatus).toBe(0);
     expect(u.lastBgpUpAt).toBe(0n);
     expect(u.lastBgpReportedAt).toBe(0n);
     expect(u.bgpRttNs).toBe(0n);
     expect(u.feedPks).toEqual([]);
+    expect(u.accessPassPubKey.equals(PublicKey.default)).toBe(true);
   });
 
   test("old layout: zeroed scalar feed slot reads as empty feedPks", () => {
     const [data] = loadFixture("user");
-    // Replace feed_pks (4 + 2*32 = 68 bytes) with the old 32-zero-byte scalar slot.
-    const old = new Uint8Array(data.length - 68 + 32);
-    old.set(data.slice(0, data.length - 68));
+    // Remove accesspass_pk and replace feed_pks with the old 32-zero-byte scalar slot.
+    const old = new Uint8Array(data.length - 100 + 32);
+    old.set(data.slice(0, data.length - 100));
     const u = deserializeUser(old);
     expect(u.feedPks).toEqual([]);
+    expect(u.accessPassPubKey.equals(PublicKey.default)).toBe(true);
   });
 });