Struct JsPrepareSubmissionRequest 

pub struct JsPrepareSubmissionRequest {
    pub user_id: String,
    pub command_id: String,
    pub commands: Option<Vec<Command>>,
    pub min_ledger_time: Option<Box<MinLedgerTime>>,
    pub act_as: Option<Vec<String>>,
    pub read_as: Option<Vec<String>>,
    pub disclosed_contracts: Option<Vec<DisclosedContract>>,
    pub synchronizer_id: String,
    pub package_id_selection_preference: Option<Vec<String>>,
    pub verbose_hashing: bool,
}

Fields

user_id: String

Uniquely identifies the participant user that prepares the transaction. Must be a valid UserIdString (as described in value.proto). Required unless authentication is used with a user token. In that case, the token’s user-id will be used for the request’s user_id.

command_id: String

Uniquely identifies the command. The triple (user_id, act_as, command_id) constitutes the change ID for the intended ledger change, where act_as is interpreted as a set of party names. The change ID can be used for matching the intended ledger changes with all their completions. Must be a valid LedgerString (as described in value.proto). Required

commands: Option<Vec<Command>>

Individual elements of this atomic command. Must be non-empty. Required

min_ledger_time: Option<Box<MinLedgerTime>>

act_as: Option<Vec<String>>

Set of parties on whose behalf the command should be executed, if submitted. If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request to read (not act) on behalf of each of the given parties. This is because this RPC merely prepares a transaction and does not execute it. Therefore read authorization is sufficient even for actAs parties. Note: This may change, and more specific authorization scope may be introduced in the future. Each element must be a valid PartyIdString (as described in value.proto). Required, must be non-empty.

read_as: Option<Vec<String>>

Set of parties on whose behalf (in addition to all parties listed in act_as) contracts can be retrieved. This affects Daml operations such as fetch, fetchByKey, lookupByKey, exercise, and exerciseByKey. Note: A command can only use contracts that are visible to at least one of the parties in act_as or read_as. This visibility check is independent from the Daml authorization rules for fetch operations. If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request to read contract data on behalf of each of the given parties. Optional

disclosed_contracts: Option<Vec<DisclosedContract>>

Additional contracts used to resolve contract & contract key lookups. Optional

synchronizer_id: String

Must be a valid synchronizer id Required

package_id_selection_preference: Option<Vec<String>>

The package-id selection preference of the client for resolving package names and interface instances in command submission and interpretation

verbose_hashing: bool

When true, the response will contain additional details on how the transaction was encoded and hashed This can be useful for troubleshooting of hash mismatches. Should only be used for debugging.

Implementations

impl JsPrepareSubmissionRequest

pub fn new( user_id: String, command_id: String, synchronizer_id: String, verbose_hashing: bool, ) -> JsPrepareSubmissionRequest

Trait Implementations

impl Clone for JsPrepareSubmissionRequest

fn clone(&self) -> JsPrepareSubmissionRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsPrepareSubmissionRequest

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

Formats the value using the given formatter.

impl Default for JsPrepareSubmissionRequest

fn default() -> JsPrepareSubmissionRequest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for JsPrepareSubmissionRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for JsPrepareSubmissionRequest

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for JsPrepareSubmissionRequest

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 JsPrepareSubmissionRequest