Struct WalletWatchParams 

pub struct WalletWatchParams {
    pub public_keys: Vec<String>,
}

control.wallet.watch params: which PUBLIC keys the node should follow.

Keys, never puzzle hashes

The node already derives addresses from the public keys it holds in its own custody, through one standard derivation. Enrolling KEYS reuses that exact derivation for a client’s keys too, so the ecosystem has ONE mapping from key to address and a client and a node can never disagree about which addresses a key covers. Enrolling puzzle hashes instead would make every client re-derive independently, and a client whose derivation window is narrower than the node’s would silently under-report the money it owns.

No key material crosses (§908)

A G1 public key is public. There is deliberately no seed, phrase, private key or signature field here, and there never may be: enrolment tells the node what to WATCH, and watching needs nothing a signature could be produced from.

Idempotent, so a client can reconcile without asking first

Submitting keys the node already follows is a SUCCESS that changes nothing — see WalletWatchResult. Duplicates WITHIN one request count once. An empty list is accepted and does nothing, because “enrol everything in this (currently empty) set” is a reconciliation a client legitimately performs.

Fields

public_keys: Vec<String>

The public keys to enrol: lowercase 96-hex, unprefixed. A 0x prefix is TOLERATED on input and normalized away by Self::validated; it is never emitted.

Implementations

impl WalletWatchParams

pub fn validated(self) -> Result<Self, ControlError>

Normalize and check every key, or reject the request as -32602 INVALID_PARAMS.

The whole request is refused when ANY key is malformed — never the well-formed subset. A partial enrolment would leave the node following fewer addresses than the client believes it asked for, and the client’s next balance read would report a shortfall as though the money were not there. One bad key is a malformed REQUEST.

Accepts exactly two spellings per key — 96 lowercase hex characters, or the same 96 preceded by 0x. Uppercase, whitespace and every other length are refused, because the contract’s hex wire form is lowercase and unprefixed everywhere else.

Trait Implementations

impl Clone for WalletWatchParams

fn clone(&self) -> WalletWatchParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ControlCall for WalletWatchParams

const METHOD: ControlMethod = ControlMethod::WalletWatch

The wire method this call invokes.

type Output = WalletWatchResult

The typed result this call returns on success.

impl Debug for WalletWatchParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WalletWatchParams

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for WalletWatchParams

impl PartialEq for WalletWatchParams

fn eq(&self, other: &WalletWatchParams) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for WalletWatchParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WalletWatchParams