Package com.daml.ledger.api.v2.interactive

Interface InteractiveSubmissionServiceOuterClass.PrepareSubmissionRequestOrBuilder

All Superinterfaces:
com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder
All Known Implementing Classes:
InteractiveSubmissionServiceOuterClass.PrepareSubmissionRequest, InteractiveSubmissionServiceOuterClass.PrepareSubmissionRequest.Builder
Enclosing class:
InteractiveSubmissionServiceOuterClass
public static interface InteractiveSubmissionServiceOuterClass.PrepareSubmissionRequestOrBuilder extends com.google.protobuf.MessageOrBuilder

  • Method Details

    • getUserId

      String getUserId()
       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.

 Optional
      string user_id = 1;
      Returns:
      The userId.

    • getUserIdBytes

      com.google.protobuf.ByteString getUserIdBytes()
       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.

 Optional
      string user_id = 1;
      Returns:
      The bytes for userId.

    • getCommandId

      String getCommandId()
       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
      string command_id = 2;
      Returns:
      The commandId.

    • getCommandIdBytes

      com.google.protobuf.ByteString getCommandIdBytes()
       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
      string command_id = 2;
      Returns:
      The bytes for commandId.

    • getCommandsList

      List<CommandsOuterClass.Command> getCommandsList()
       Individual elements of this atomic command. Must be non-empty.
 Limitation: Only single command transaction are currently supported by the API.
 The field is marked as repeated in preparation for future support of multiple commands.

 Required: must be non-empty
      repeated .com.daml.ledger.api.v2.Command commands = 3;

    • getCommands

      CommandsOuterClass.Command getCommands(int index)
       Individual elements of this atomic command. Must be non-empty.
 Limitation: Only single command transaction are currently supported by the API.
 The field is marked as repeated in preparation for future support of multiple commands.

 Required: must be non-empty
      repeated .com.daml.ledger.api.v2.Command commands = 3;

    • getCommandsCount

      int getCommandsCount()
       Individual elements of this atomic command. Must be non-empty.
 Limitation: Only single command transaction are currently supported by the API.
 The field is marked as repeated in preparation for future support of multiple commands.

 Required: must be non-empty
      repeated .com.daml.ledger.api.v2.Command commands = 3;

    • getCommandsOrBuilderList

      List<? extends CommandsOuterClass.CommandOrBuilder> getCommandsOrBuilderList()
       Individual elements of this atomic command. Must be non-empty.
 Limitation: Only single command transaction are currently supported by the API.
 The field is marked as repeated in preparation for future support of multiple commands.

 Required: must be non-empty
      repeated .com.daml.ledger.api.v2.Command commands = 3;

    • getCommandsOrBuilder

      CommandsOuterClass.CommandOrBuilder getCommandsOrBuilder(int index)
       Individual elements of this atomic command. Must be non-empty.
 Limitation: Only single command transaction are currently supported by the API.
 The field is marked as repeated in preparation for future support of multiple commands.

 Required: must be non-empty
      repeated .com.daml.ledger.api.v2.Command commands = 3;

    • hasMinLedgerTime

      boolean hasMinLedgerTime()
       Optional
      .com.daml.ledger.api.v2.interactive.MinLedgerTime min_ledger_time = 4;
      Returns:
      Whether the minLedgerTime field is set.

    • getMinLedgerTime

      InteractiveSubmissionServiceOuterClass.MinLedgerTime getMinLedgerTime()
       Optional
      .com.daml.ledger.api.v2.interactive.MinLedgerTime min_ledger_time = 4;
      Returns:
      The minLedgerTime.

    • getMinLedgerTimeOrBuilder

      InteractiveSubmissionServiceOuterClass.MinLedgerTimeOrBuilder getMinLedgerTimeOrBuilder()
       Optional
      .com.daml.ledger.api.v2.interactive.MinLedgerTime min_ledger_time = 4;

    • hasMaxRecordTime

      boolean hasMaxRecordTime()
       Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`.
 If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
 with a new valid max_record_time.
 Use this to limit the time-to-life of a prepared transaction,
 which is useful to know when it can definitely not be accepted
 anymore and resorting to preparing another transaction for the same
 intent is safe again.

 Optional
      optional .google.protobuf.Timestamp max_record_time = 11;
      Returns:
      Whether the maxRecordTime field is set.

    • getMaxRecordTime

      com.google.protobuf.Timestamp getMaxRecordTime()
       Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`.
 If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
 with a new valid max_record_time.
 Use this to limit the time-to-life of a prepared transaction,
 which is useful to know when it can definitely not be accepted
 anymore and resorting to preparing another transaction for the same
 intent is safe again.

 Optional
      optional .google.protobuf.Timestamp max_record_time = 11;
      Returns:
      The maxRecordTime.

    • getMaxRecordTimeOrBuilder

      com.google.protobuf.TimestampOrBuilder getMaxRecordTimeOrBuilder()
       Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`.
 If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
 with a new valid max_record_time.
 Use this to limit the time-to-life of a prepared transaction,
 which is useful to know when it can definitely not be accepted
 anymore and resorting to preparing another transaction for the same
 intent is safe again.

 Optional
      optional .google.protobuf.Timestamp max_record_time = 11;

    • getActAsList

      List<String> getActAsList()
       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
      repeated string act_as = 5;
      Returns:
      A list containing the actAs.

    • getActAsCount

      int getActAsCount()
       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
      repeated string act_as = 5;
      Returns:
      The count of actAs.

    • getActAs

      String getActAs(int index)
       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
      repeated string act_as = 5;
      Parameters:
      index - The index of the element to return.
      Returns:
      The actAs at the given index.

    • getActAsBytes

      com.google.protobuf.ByteString getActAsBytes(int index)
       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
      repeated string act_as = 5;
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the actAs at the given index.

    • getReadAsList

      List<String> getReadAsList()
       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: can be empty
      repeated string read_as = 6;
      Returns:
      A list containing the readAs.

    • getReadAsCount

      int getReadAsCount()
       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: can be empty
      repeated string read_as = 6;
      Returns:
      The count of readAs.

    • getReadAs

      String getReadAs(int index)
       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: can be empty
      repeated string read_as = 6;
      Parameters:
      index - The index of the element to return.
      Returns:
      The readAs at the given index.

    • getReadAsBytes

      com.google.protobuf.ByteString getReadAsBytes(int index)
       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: can be empty
      repeated string read_as = 6;
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the readAs at the given index.

    • getDisclosedContractsList

      List<CommandsOuterClass.DisclosedContract> getDisclosedContractsList()
       Additional contracts used to resolve contract & contract key lookups.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7;

    • getDisclosedContracts

      CommandsOuterClass.DisclosedContract getDisclosedContracts(int index)
       Additional contracts used to resolve contract & contract key lookups.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7;

    • getDisclosedContractsCount

      int getDisclosedContractsCount()
       Additional contracts used to resolve contract & contract key lookups.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7;

    • getDisclosedContractsOrBuilderList

      List<? extends CommandsOuterClass.DisclosedContractOrBuilder> getDisclosedContractsOrBuilderList()
       Additional contracts used to resolve contract & contract key lookups.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7;

    • getDisclosedContractsOrBuilder

      CommandsOuterClass.DisclosedContractOrBuilder getDisclosedContractsOrBuilder(int index)
       Additional contracts used to resolve contract & contract key lookups.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7;

    • getSynchronizerId

      String getSynchronizerId()
       Must be a valid synchronizer id
 If not set, a suitable synchronizer that this node is connected to will be chosen

 Optional
      string synchronizer_id = 8;
      Returns:
      The synchronizerId.

    • getSynchronizerIdBytes

      com.google.protobuf.ByteString getSynchronizerIdBytes()
       Must be a valid synchronizer id
 If not set, a suitable synchronizer that this node is connected to will be chosen

 Optional
      string synchronizer_id = 8;
      Returns:
      The bytes for synchronizerId.

    • getPackageIdSelectionPreferenceList

      List<String> getPackageIdSelectionPreferenceList()
       The package-id selection preference of the client for resolving
 package names and interface instances in command submission and interpretation

 Optional: can be empty
      repeated string package_id_selection_preference = 9;
      Returns:
      A list containing the packageIdSelectionPreference.

    • getPackageIdSelectionPreferenceCount

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

 Optional: can be empty
      repeated string package_id_selection_preference = 9;
      Returns:
      The count of packageIdSelectionPreference.

    • getPackageIdSelectionPreference

      String getPackageIdSelectionPreference(int index)
       The package-id selection preference of the client for resolving
 package names and interface instances in command submission and interpretation

 Optional: can be empty
      repeated string package_id_selection_preference = 9;
      Parameters:
      index - The index of the element to return.
      Returns:
      The packageIdSelectionPreference at the given index.

    • getPackageIdSelectionPreferenceBytes

      com.google.protobuf.ByteString getPackageIdSelectionPreferenceBytes(int index)
       The package-id selection preference of the client for resolving
 package names and interface instances in command submission and interpretation

 Optional: can be empty
      repeated string package_id_selection_preference = 9;
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the packageIdSelectionPreference at the given index.

    • getVerboseHashing

      boolean getVerboseHashing()
       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.
 Defaults to false

 Optional
      bool verbose_hashing = 10;
      Returns:
      The verboseHashing.

    • getPrefetchContractKeysList

      List<CommandsOuterClass.PrefetchContractKey> getPrefetchContractKeysList()
       Fetches the contract keys into the caches to speed up the command processing.
 Should only contain contract keys that are expected to be resolved during interpretation of the commands.
 Keys of disclosed contracts do not need prefetching.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15;

    • getPrefetchContractKeys

      CommandsOuterClass.PrefetchContractKey getPrefetchContractKeys(int index)
       Fetches the contract keys into the caches to speed up the command processing.
 Should only contain contract keys that are expected to be resolved during interpretation of the commands.
 Keys of disclosed contracts do not need prefetching.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15;

    • getPrefetchContractKeysCount

      int getPrefetchContractKeysCount()
       Fetches the contract keys into the caches to speed up the command processing.
 Should only contain contract keys that are expected to be resolved during interpretation of the commands.
 Keys of disclosed contracts do not need prefetching.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15;

    • getPrefetchContractKeysOrBuilderList

      List<? extends CommandsOuterClass.PrefetchContractKeyOrBuilder> getPrefetchContractKeysOrBuilderList()
       Fetches the contract keys into the caches to speed up the command processing.
 Should only contain contract keys that are expected to be resolved during interpretation of the commands.
 Keys of disclosed contracts do not need prefetching.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15;

    • getPrefetchContractKeysOrBuilder

      CommandsOuterClass.PrefetchContractKeyOrBuilder getPrefetchContractKeysOrBuilder(int index)
       Fetches the contract keys into the caches to speed up the command processing.
 Should only contain contract keys that are expected to be resolved during interpretation of the commands.
 Keys of disclosed contracts do not need prefetching.

 Optional: can be empty
      repeated .com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15;

    • hasEstimateTrafficCost

      boolean hasEstimateTrafficCost()
       Hints to improve the accuracy of traffic cost estimation.
 The estimation logic assumes that this node will be used for the execution of the transaction
 If another node is used instead, the estimation may be less precise.
 Request amplification is not accounted for in the estimation: each amplified request will
 result in the cost of the confirmation request to be charged additionally.

 Traffic cost estimation is enabled by default if this field is not set
 To turn off cost estimation, set the CostEstimationHints#disabled field to true

 Optional
      optional .com.daml.ledger.api.v2.interactive.CostEstimationHints estimate_traffic_cost = 16;
      Returns:
      Whether the estimateTrafficCost field is set.

    • getEstimateTrafficCost

      InteractiveSubmissionServiceOuterClass.CostEstimationHints getEstimateTrafficCost()
       Hints to improve the accuracy of traffic cost estimation.
 The estimation logic assumes that this node will be used for the execution of the transaction
 If another node is used instead, the estimation may be less precise.
 Request amplification is not accounted for in the estimation: each amplified request will
 result in the cost of the confirmation request to be charged additionally.

 Traffic cost estimation is enabled by default if this field is not set
 To turn off cost estimation, set the CostEstimationHints#disabled field to true

 Optional
      optional .com.daml.ledger.api.v2.interactive.CostEstimationHints estimate_traffic_cost = 16;
      Returns:
      The estimateTrafficCost.

    • getEstimateTrafficCostOrBuilder

      InteractiveSubmissionServiceOuterClass.CostEstimationHintsOrBuilder getEstimateTrafficCostOrBuilder()
       Hints to improve the accuracy of traffic cost estimation.
 The estimation logic assumes that this node will be used for the execution of the transaction
 If another node is used instead, the estimation may be less precise.
 Request amplification is not accounted for in the estimation: each amplified request will
 result in the cost of the confirmation request to be charged additionally.

 Traffic cost estimation is enabled by default if this field is not set
 To turn off cost estimation, set the CostEstimationHints#disabled field to true

 Optional
      optional .com.daml.ledger.api.v2.interactive.CostEstimationHints estimate_traffic_cost = 16;

    • hasHashingSchemeVersion

      boolean hasHashingSchemeVersion()
       The hashing scheme version to be used when building the hash.
 Defaults to HASHING_SCHEME_VERSION_V2.

 Optional
      optional .com.daml.ledger.api.v2.interactive.HashingSchemeVersion hashing_scheme_version = 17;
      Returns:
      Whether the hashingSchemeVersion field is set.

    • getHashingSchemeVersionValue

      int getHashingSchemeVersionValue()
       The hashing scheme version to be used when building the hash.
 Defaults to HASHING_SCHEME_VERSION_V2.

 Optional
      optional .com.daml.ledger.api.v2.interactive.HashingSchemeVersion hashing_scheme_version = 17;
      Returns:
      The enum numeric value on the wire for hashingSchemeVersion.

    • getHashingSchemeVersion

      InteractiveSubmissionServiceOuterClass.HashingSchemeVersion getHashingSchemeVersion()
       The hashing scheme version to be used when building the hash.
 Defaults to HASHING_SCHEME_VERSION_V2.

 Optional
      optional .com.daml.ledger.api.v2.interactive.HashingSchemeVersion hashing_scheme_version = 17;
      Returns:
      The hashingSchemeVersion.

    • hasTapsMaxPasses

      boolean hasTapsMaxPasses()
       The maximum number of passes for the Topology-Aware Package Selection (TAPS).
 Higher values can increase the chance of successful package selection for routing of interpreted transactions.
 If unset, this defaults to the value defined in the participant configuration.
 The provided value must not exceed the limit specified in the participant configuration.

 Optional
      optional uint32 taps_max_passes = 18;
      Returns:
      Whether the tapsMaxPasses field is set.

    • getTapsMaxPasses

      int getTapsMaxPasses()
       The maximum number of passes for the Topology-Aware Package Selection (TAPS).
 Higher values can increase the chance of successful package selection for routing of interpreted transactions.
 If unset, this defaults to the value defined in the participant configuration.
 The provided value must not exceed the limit specified in the participant configuration.

 Optional
      optional uint32 taps_max_passes = 18;
      Returns:
      The tapsMaxPasses.