Struct Prepare 

pub struct Prepare { /* private fields */ }

A submission to be interpreted but not authorized: the prepare half of interactive submission.

This carries what PrepareSubmissionRequest carries, and nothing else. Submit is deliberately not reused: it has a deduplication period and a workflow_id that preparation has no field for, and accepting them here would silently drop them. The de-duplication period, the transaction shape and the submission id belong to execution and are set on Executable. In the other direction, preparation has four fields a plain submission does not: verbose_hashing, max_record_time, the hashing scheme, and traffic-cost estimation.

Implementations

impl Prepare

pub fn new(act_as: impl Into<String>) -> Self

Prepare a submission acting as a single party.

pub fn new_multi(act_as: Vec<String>) -> Self

Prepare a submission acting as several parties.

Each of them signs: the participant requires a signature per party in act_as, so a transaction prepared for two parties needs two.

pub fn add_command(self, command: Command) -> Self

Add a command — build them with create / exercise, or from generated bindings.

pub fn add_commands(self, commands: impl IntoIterator<Item = Command>) -> Self

Add several commands, executed atomically.

pub fn with_command_id(self, command_id: impl Into<String>) -> Self

Set the command id, one component of the change ID the Ledger API de-duplicates on (user_id, act_as, command_id).

Left unset, a fresh UUID is generated at prepare time and carried through execution, so re-executing the same Executable is de-duplicated rather than committed twice.

pub fn with_user_id(self, user_id: impl Into<String>) -> Self

Set the user id. Defaults to the one derived from the bearer token.

pub fn with_read_as(self, read_as: Vec<String>) -> Self

Parties to read as, in addition to those acting.

pub fn with_synchronizer_id(self, synchronizer_id: impl Into<String>) -> Self

Pin the submission to a synchronizer.

pub fn with_disclosed_contracts(self, contracts: Vec<DisclosedContract>) -> Self

Attach explicitly disclosed contracts — the created_event_blob path for contracts the submitting party cannot see on its own.

pub fn with_package_id_selection_preference( self, package_ids: Vec<String>, ) -> Self

Prefer these package ids when several satisfy a package-name reference.

pub fn with_prefetch_contract_keys(self, keys: Vec<PrefetchContractKey>) -> Self

Fetch these contract keys into the participant’s cache before interpretation.

pub fn with_min_ledger_time_abs(self, time: Timestamp) -> Self

Lower bound for the transaction’s ledger time, absolute.

Mutually exclusive with with_min_ledger_time_rel; the participant rejects both at once.

pub fn with_min_ledger_time_rel(self, duration: Duration) -> Self

Lower bound for the transaction’s ledger time, relative to when the participant receives the request.

Mutually exclusive with with_min_ledger_time_abs.

pub fn with_verbose_hashing(self, verbose: bool) -> Self

Ask the participant to return the hashing details it used.

For debugging a hash mismatch. The participant may refuse — it is configurable server-side — and what comes back describes internal structure, so it is off by default.

pub fn with_max_record_time(self, time: Timestamp) -> Self

Bound how long the prepared transaction can be executed for.

Past this record time the participant will certainly refuse it, which is what makes preparing a fresh transaction for the same intent safe again: without a bound, “it might still commit” and “prepare another” are both true at once.

pub fn with_hashing_scheme_version(self, version: HashingSchemeVersion) -> Self

Choose the hashing scheme. Defaults to V2, which this SDK asks for explicitly rather than leaving to the participant; a transaction that uses contract keys needs V3.

The scheme decides what the hash covers, so it is echoed in the response and sent back with the signature — the participant must verify under the same scheme it hashed with. Under V2 and V3 the SDK recomputes the hash from the prepared transaction and refuses a response whose hash is of something else. Any other scheme is refused unless trust_participant_hash is set.

pub fn trust_participant_hash(self) -> Self

Sign the participant’s hash as it returns it, for a hashing scheme this SDK cannot recompute (anything but V2 and V3).

Without this a prepared transaction hashed under such a scheme is refused: the hash is what the signature covers, and an unchecked one signs whatever the participant hashed, which need not be the transaction it returned. Setting it accepts that for this submission. It does not switch off the check under V2 and V3.

pub fn with_taps_max_passes(self, passes: u32) -> Self

Cap the topology-aware package selection passes (defaults to the participant’s configured value).

pub fn without_traffic_cost_estimation(self) -> Self

Turn off the traffic-cost estimate the participant returns by default.

pub fn act_as(&self) -> &[String]

The parties this will act as.

pub fn read_as(&self) -> &[String]

The parties this will read as, beyond those acting.

pub fn disclosed_contracts(&self) -> &[DisclosedContract]

The contracts this will disclose.

A token-standard choice is meaningless without the registry’s disclosures, so a caller assembling one wants to see them before sending, not after a rejection.

Trait Implementations

impl Clone for Prepare

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 Prepare

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

Formats the value using the given formatter.