Struct AdminClient 

pub struct AdminClient { /* private fields */ }

A client for Canton’s Ledger-API admin services: PartyManagementService and UserManagementService.

Served on the Ledger API port (e.g. :3901) — the same endpoint and auth as canton_ledger. Party-management RPCs require the ParticipantAdmin right; the current_user* self-inspect calls do not.

Implementations

impl AdminClient

pub fn connect_lazy(config: Config) -> Result<Self>

Build a lazily-connected client. Returns immediately; the TCP/TLS handshake happens on the first RPC.

Errors

Returns Error::InvalidRequest if the endpoint is not a valid URI.

pub async fn participant_id(&self) -> Result<String>

The participant’s id (GetParticipantId). Works with any authenticated token.

Errors

Returns an Error if the RPC fails.

pub async fn allocate_party( &self, party_id_hint: Option<&str>, ) -> Result<PartyDetails>

Allocate a new party (AllocateParty). party_id_hint suggests the local part of the party id; the participant returns the actual PartyDetails (party = "<hint>::<fingerprint>").

Requires the ParticipantAdmin right. Not retried: party allocation is a non-idempotent topology mutation (a lost response must not double allocate), so a transient failure surfaces to the caller.

Errors

Returns an Error if authentication/authorization fails, the RPC fails, or the response carries no party details.

pub async fn generate_external_party_topology( &self, synchronizer: &str, party_hint: &str, public_key: &PublicKey, ) -> Result<ExternalPartyTopology>

Ask the participant what allocating an external party for public_key would look like, without allocating it.

The first half of external-party onboarding. The participant computes the key’s fingerprint and the party id derived from it, builds the onboarding topology transactions, and returns one hash over them. None of it is submitted: that is allocate_external_party, after the key has signed the hash.

Errors

Returns an Error if the RPC fails, or Error::UnexpectedResponse if the participant answers without a hash to sign or without the fingerprint — either of which would leave the caller unable to sign as this party at all.

pub async fn allocate_external_party( &self, synchronizer: &str, topology: &ExternalPartyTopology, signer: &dyn Signer, user_id: &str, ) -> Result<String>

Allocate the external party described by topology, authorized by signer.

The second half. The signature is over multi_hash — one hash covering every onboarding transaction, so one signature authorizes the whole set — and it is what proves the party controls the key being registered for it.

user_id gets act_as rights on the new party; empty grants none.

Returns the allocated party id. This waits for the allocation to reach the synchronizer, so the party is usable when it returns.

Errors

Returns an Error if signing fails or the RPC does. A signature made by a key other than the one in the topology is rejected by the participant, not here.

pub async fn list_known_parties_page( &self, page_size: i32, page_token: Option<String>, ) -> Result<(Vec<PartyDetails>, Option<String>)>

List one page of known parties (ListKnownParties). Pass the returned token to fetch the next page; page_size 0 uses the server default.

Errors

Returns an Error if authentication/authorization or the RPC fails.

pub async fn list_known_parties(&self) -> Result<Vec<PartyDetails>>

All known parties, following pagination internally (ListKnownParties).

Errors

Returns an Error if authentication/authorization or any page RPC fails.

pub async fn get_parties( &self, parties: Vec<String>, ) -> Result<Vec<PartyDetails>>

Details for specific parties (GetParties). Unknown parties are silently omitted from the result rather than erroring.

Errors

Returns an Error if authentication/authorization or the RPC fails.

pub async fn current_user(&self) -> Result<User>

The authenticated user’s own record (GetUser with an empty user id). Authorized for any authenticated token (no admin right needed).

Errors

Returns an Error if the RPC fails or the response carries no user.

pub async fn get_user(&self, user_id: &str) -> Result<User>

A user’s record by id (GetUser); an empty user_id means the authenticated user.

Errors

Returns an Error if the RPC fails or the response carries no user.

pub async fn current_user_rights(&self) -> Result<Vec<Right>>

The authenticated user’s own rights (ListUserRights with an empty user id). Authorized for any authenticated token.

Errors

Returns an Error if the RPC fails.

pub async fn list_user_rights(&self, user_id: &str) -> Result<Vec<Right>>

A user’s rights by id (ListUserRights); an empty user_id means the authenticated user.

Errors

Returns an Error if the RPC fails.

pub async fn list_packages(&self) -> Result<Vec<String>>

The ids of all Daml packages known to the participant (PackageService.ListPackages).

Errors

Returns an Error if authentication or the RPC fails.

pub async fn get_package(&self, package_id: &str) -> Result<Vec<u8>>

The status of a package on the participant (PackageService.GetPackageStatus): Registered if the package is known, Unspecified otherwise.

Errors

Download a package the participant knows, as ArchivePayload bytes.

This is what canton_lf::decode_payload reads — the inner half of an archive. A DAR entry is the whole Archive, payload and hash together, and canton_lf::decode_package reads that one; the Ledger API returns the parts separately, so the two are different bytes and each has its own decoder.

Bindings can therefore be generated from what a participant has actually vetted, rather than from a DAR file that has to be found somewhere — and for a package that only ever existed on a network, there may be no such file at all.

The payload is hashed and the digest checked against package_id before the bytes are handed back. A package id is the hash of its payload, so that check is what makes asking by id pin the content exactly, with nothing further to checksum.

Errors

Returns an Error if the RPC fails, and Error::UnexpectedResponse if the participant answers with no payload or whose bytes do not hash to the id that was asked for.

pub async fn get_package_status( &self, package_id: &str, ) -> Result<PackageStatus>

Returns an Error if authentication or the RPC fails.

pub async fn acting_parties(&self) -> Result<Vec<String>>

The specific parties the authenticated user may act as — the CanActAs subset of Self::current_user_rights. Supersedes the ad-hoc party discovery used in early tests.

Note: a user granted the wildcard CanActAsAnyParty right may act as any party yet carries no explicit CanActAs entries, so this returns an empty list for such users — an empty result means “no specific parties”, not necessarily “cannot act”. Inspect Self::current_user_rights directly if you need the wildcard.

Errors

Returns an Error if the underlying rights RPC fails.

Trait Implementations

impl Clone for AdminClient

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AdminClient

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

Formats the value using the given formatter.