interactive

type CostEstimation struct {

	// Timestamp at which the estimation was made
	EstimationTimestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=estimation_timestamp,json=estimationTimestamp,proto3" json:"estimation_timestamp,omitempty"`
	// Estimated traffic cost of the confirmation request associated with the transaction
	ConfirmationRequestTrafficCostEstimation uint64 `` /* 188-byte string literal not displayed */
	// Estimated traffic cost of the confirmation response associated with the transaction
	// This field can also be used as an indication of the cost that other potential confirming nodes
	// of the party will incur to approve or reject the transaction
	ConfirmationResponseTrafficCostEstimation uint64 `` /* 191-byte string literal not displayed */
	// Sum of the fields above
	TotalTrafficCostEstimation uint64 `` /* 144-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CostEstimationHints struct {

	// Disable cost estimation
	// Default (not set) is false
	Disabled bool `protobuf:"varint,1,opt,name=disabled,proto3" json:"disabled,omitempty"`
	// Details on the keys that will be used to sign the transaction (how many and of which type).
	// Signature size impacts the cost of the transaction.
	// If empty, the signature sizes will be approximated with threshold-many signatures (where threshold is defined
	// in the PartyToKeyMapping of the external party), using keys in the order they are registered.
	// Optional (empty list is equivalent to not providing this field)
	ExpectedSignatures []v2.SigningAlgorithmSpec `` /* 172-byte string literal not displayed */
	// contains filtered or unexported fields
}

type DamlTransaction struct {

	// serialization version, will be >= max(nodes version)
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Root nodes of the transaction
	Roots []string `protobuf:"bytes,2,rep,name=roots,proto3" json:"roots,omitempty"`
	// List of nodes in the transaction
	Nodes []*DamlTransaction_Node `protobuf:"bytes,3,rep,name=nodes,proto3" json:"nodes,omitempty"`
	// Node seeds are values associated with certain nodes used for generating cryptographic salts
	NodeSeeds []*DamlTransaction_NodeSeed `protobuf:"bytes,4,rep,name=node_seeds,json=nodeSeeds,proto3" json:"node_seeds,omitempty"`
	// contains filtered or unexported fields
}

type DamlTransaction_Node struct {
	NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// Versioned node
	//
	// Types that are valid to be assigned to VersionedNode:
	//
	//	*DamlTransaction_Node_V1
	VersionedNode isDamlTransaction_Node_VersionedNode `protobuf_oneof:"versioned_node"`
	// contains filtered or unexported fields
}

type DamlTransaction_NodeSeed struct {
	NodeId int32  `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Seed   []byte `protobuf:"bytes,2,opt,name=seed,proto3" json:"seed,omitempty"`
	// contains filtered or unexported fields
}

type DamlTransaction_Node_V1 struct {
	// Start at 1000 so we can add more fields before if necessary
	// When new versions will be added, they will show here
	V1 *v1.Node `protobuf:"bytes,1000,opt,name=v1,proto3,oneof"`
}

type ExecuteSubmissionAndWaitForTransactionRequest struct {

	// the prepared transaction
	// Typically this is the value of the `prepared_transaction` field in `PrepareSubmissionResponse`
	// obtained from calling `prepareSubmission`.
	// Required
	PreparedTransaction *PreparedTransaction `protobuf:"bytes,1,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	// The party(ies) signatures that authorize the prepared submission to be executed by this node.
	// Each party can provide one or more signatures..
	// and one or more parties can sign.
	// Note that currently, only single party submissions are supported.
	// Required
	PartySignatures *PartySignatures `protobuf:"bytes,2,opt,name=party_signatures,json=partySignatures,proto3" json:"party_signatures,omitempty"`
	// Specifies the deduplication period for the change ID (See PrepareSubmissionRequest).
	// If omitted, the participant will assume the configured maximum deduplication time.
	// Optional
	//
	// Types that are valid to be assigned to DeduplicationPeriod:
	//
	//	*ExecuteSubmissionAndWaitForTransactionRequest_DeduplicationDuration
	//	*ExecuteSubmissionAndWaitForTransactionRequest_DeduplicationOffset
	DeduplicationPeriod isExecuteSubmissionAndWaitForTransactionRequest_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// A unique identifier to distinguish completions for different submissions with the same change ID.
	// Typically a random UUID. Applications are expected to use a different UUID for each retry of a submission
	// with the same change ID.
	// Must be a valid LedgerString (as described in “value.proto“).
	//
	// Required
	SubmissionId string `protobuf:"bytes,5,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// See [PrepareSubmissionRequest.user_id]
	// Optional
	UserId string `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The hashing scheme version used when building the hash
	// Required
	HashingSchemeVersion HashingSchemeVersion `` /* 185-byte string literal not displayed */
	// If set will influence the chosen ledger effective time but will not result in a submission delay so any override
	// should be scheduled to executed within the window allowed by synchronizer.
	// Optional
	MinLedgerTime *MinLedgerTime `protobuf:"bytes,8,opt,name=min_ledger_time,json=minLedgerTime,proto3" json:"min_ledger_time,omitempty"`
	// If no “transaction_format“ is provided, a default will be used where “transaction_shape“ is set to
	// TRANSACTION_SHAPE_ACS_DELTA, “event_format“ is defined with “filters_by_party“ containing wildcard-template
	// filter for all original “act_as“ and “read_as“ parties and the “verbose“ flag is set.
	// When the “transaction_shape“ TRANSACTION_SHAPE_ACS_DELTA shape is used (explicitly or is defaulted to as explained above),
	// events will only be returned if the submitting party is hosted on this node.
	// Optional
	TransactionFormat *v2.TransactionFormat `protobuf:"bytes,9,opt,name=transaction_format,json=transactionFormat,proto3" json:"transaction_format,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteSubmissionAndWaitForTransactionRequest_DeduplicationDuration struct {
	// Specifies the length of the deduplication period.
	// It is interpreted relative to the local clock at some point during the submission's processing.
	// Must be non-negative. Must not exceed the maximum deduplication time.
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=deduplication_duration,json=deduplicationDuration,proto3,oneof"`
}

type ExecuteSubmissionAndWaitForTransactionRequest_DeduplicationOffset struct {
	// Specifies the start of the deduplication period by a completion stream offset (exclusive).
	// Must be a valid absolute offset (positive integer).
	DeduplicationOffset int64 `protobuf:"varint,4,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type ExecuteSubmissionAndWaitForTransactionResponse struct {

	// The transaction that resulted from the submitted command.
	// The transaction might contain no events (request conditions result in filtering out all of them).
	// Required
	Transaction *v2.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteSubmissionAndWaitRequest struct {

	// the prepared transaction
	// Typically this is the value of the `prepared_transaction` field in `PrepareSubmissionResponse`
	// obtained from calling `prepareSubmission`.
	// Required
	PreparedTransaction *PreparedTransaction `protobuf:"bytes,1,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	// The party(ies) signatures that authorize the prepared submission to be executed by this node.
	// Each party can provide one or more signatures..
	// and one or more parties can sign.
	// Note that currently, only single party submissions are supported.
	// Required
	PartySignatures *PartySignatures `protobuf:"bytes,2,opt,name=party_signatures,json=partySignatures,proto3" json:"party_signatures,omitempty"`
	// Specifies the deduplication period for the change ID (See PrepareSubmissionRequest).
	// If omitted, the participant will assume the configured maximum deduplication time.
	// Optional
	//
	// Types that are valid to be assigned to DeduplicationPeriod:
	//
	//	*ExecuteSubmissionAndWaitRequest_DeduplicationDuration
	//	*ExecuteSubmissionAndWaitRequest_DeduplicationOffset
	DeduplicationPeriod isExecuteSubmissionAndWaitRequest_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// A unique identifier to distinguish completions for different submissions with the same change ID.
	// Typically a random UUID. Applications are expected to use a different UUID for each retry of a submission
	// with the same change ID.
	// Must be a valid LedgerString (as described in “value.proto“).
	//
	// Required
	SubmissionId string `protobuf:"bytes,5,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// See [PrepareSubmissionRequest.user_id]
	// Optional
	UserId string `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The hashing scheme version used when building the hash
	// Required
	HashingSchemeVersion HashingSchemeVersion `` /* 185-byte string literal not displayed */
	// If set will influence the chosen ledger effective time but will not result in a submission delay so any override
	// should be scheduled to executed within the window allowed by synchronizer.
	// Optional
	MinLedgerTime *MinLedgerTime `protobuf:"bytes,8,opt,name=min_ledger_time,json=minLedgerTime,proto3" json:"min_ledger_time,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteSubmissionAndWaitRequest_DeduplicationDuration struct {
	// Specifies the length of the deduplication period.
	// It is interpreted relative to the local clock at some point during the submission's processing.
	// Must be non-negative. Must not exceed the maximum deduplication time.
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=deduplication_duration,json=deduplicationDuration,proto3,oneof"`
}

type ExecuteSubmissionAndWaitRequest_DeduplicationOffset struct {
	// Specifies the start of the deduplication period by a completion stream offset (exclusive).
	// Must be a valid absolute offset (positive integer).
	DeduplicationOffset int64 `protobuf:"varint,4,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type ExecuteSubmissionAndWaitResponse struct {

	// The id of the transaction that resulted from the submitted command.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	UpdateId string `protobuf:"bytes,1,opt,name=update_id,json=updateId,proto3" json:"update_id,omitempty"`
	// The details of the offset field are described in “community/ledger-api/README.md“.
	// Required
	CompletionOffset int64 `protobuf:"varint,2,opt,name=completion_offset,json=completionOffset,proto3" json:"completion_offset,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteSubmissionRequest struct {

	// the prepared transaction
	// Typically this is the value of the `prepared_transaction` field in `PrepareSubmissionResponse`
	// obtained from calling `prepareSubmission`.
	// Required
	PreparedTransaction *PreparedTransaction `protobuf:"bytes,1,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	// The party(ies) signatures that authorize the prepared submission to be executed by this node.
	// Each party can provide one or more signatures..
	// and one or more parties can sign.
	// Note that currently, only single party submissions are supported.
	// Required
	PartySignatures *PartySignatures `protobuf:"bytes,2,opt,name=party_signatures,json=partySignatures,proto3" json:"party_signatures,omitempty"`
	// Specifies the deduplication period for the change ID (See PrepareSubmissionRequest).
	// If omitted, the participant will assume the configured maximum deduplication time.
	// Optional
	//
	// Types that are valid to be assigned to DeduplicationPeriod:
	//
	//	*ExecuteSubmissionRequest_DeduplicationDuration
	//	*ExecuteSubmissionRequest_DeduplicationOffset
	DeduplicationPeriod isExecuteSubmissionRequest_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// A unique identifier to distinguish completions for different submissions with the same change ID.
	// Typically a random UUID. Applications are expected to use a different UUID for each retry of a submission
	// with the same change ID.
	// Must be a valid LedgerString (as described in “value.proto“).
	//
	// Required
	SubmissionId string `protobuf:"bytes,5,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// See [PrepareSubmissionRequest.user_id]
	// Optional
	UserId string `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The hashing scheme version used when building the hash
	// Required
	HashingSchemeVersion HashingSchemeVersion `` /* 185-byte string literal not displayed */
	// If set will influence the chosen ledger effective time but will not result in a submission delay so any override
	// should be scheduled to executed within the window allowed by synchronizer.
	// Optional
	MinLedgerTime *MinLedgerTime `protobuf:"bytes,8,opt,name=min_ledger_time,json=minLedgerTime,proto3" json:"min_ledger_time,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteSubmissionRequest_DeduplicationDuration struct {
	// Specifies the length of the deduplication period.
	// It is interpreted relative to the local clock at some point during the submission's processing.
	// Must be non-negative. Must not exceed the maximum deduplication time.
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,3,opt,name=deduplication_duration,json=deduplicationDuration,proto3,oneof"`
}

type ExecuteSubmissionRequest_DeduplicationOffset struct {
	// Specifies the start of the deduplication period by a completion stream offset (exclusive).
	// Must be a valid absolute offset (positive integer).
	DeduplicationOffset int64 `protobuf:"varint,4,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type ExecuteSubmissionResponse struct {
	// contains filtered or unexported fields
}

type GetPreferredPackageVersionRequest struct {

	// The parties whose participants' vetting state should be considered when resolving the preferred package.
	// Required
	Parties []string `protobuf:"bytes,1,rep,name=parties,proto3" json:"parties,omitempty"`
	// The package-name for which the preferred package should be resolved.
	// Required
	PackageName string `protobuf:"bytes,2,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// The synchronizer whose vetting state should be used for resolving this query.
	// If not specified, the vetting states of all synchronizers to which the participant is connected are used.
	// Optional
	SynchronizerId string `protobuf:"bytes,3,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// The timestamp at which the package vetting validity should be computed
	// on the latest topology snapshot as seen by the participant.
	// If not provided, the participant's current clock time is used.
	// Optional
	VettingValidAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=vetting_valid_at,json=vettingValidAt,proto3" json:"vetting_valid_at,omitempty"`
	// contains filtered or unexported fields
}

type GetPreferredPackageVersionResponse struct {

	// Not populated when no preferred package is found
	// Optional
	PackagePreference *PackagePreference `protobuf:"bytes,1,opt,name=package_preference,json=packagePreference,proto3" json:"package_preference,omitempty"`
	// contains filtered or unexported fields
}

type GetPreferredPackagesRequest struct {

	// The package-name vetting requirements for which the preferred packages should be resolved.
	//
	// Generally it is enough to provide the requirements for the intended command's root package-names.
	// Additional package-name requirements can be provided when additional Daml transaction informees need to use
	// package dependencies of the command's root packages.
	//
	// Required
	PackageVettingRequirements []*PackageVettingRequirement `` /* 141-byte string literal not displayed */
	// The synchronizer whose vetting state should be used for resolving this query.
	// If not specified, the vetting states of all synchronizers to which the participant is connected are used.
	// Optional
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// The timestamp at which the package vetting validity should be computed
	// on the latest topology snapshot as seen by the participant.
	// If not provided, the participant's current clock time is used.
	// Optional
	VettingValidAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=vetting_valid_at,json=vettingValidAt,proto3" json:"vetting_valid_at,omitempty"`
	// contains filtered or unexported fields
}

type GetPreferredPackagesResponse struct {

	// The package references of the preferred packages.
	// Must contain one package reference for each requested package-name.
	//
	// If you build command submissions whose content depends on the returned
	// preferred packages, then we recommend submitting the preferred package-ids
	// in the “package_id_selection_preference“ of the command submission to
	// avoid race conditions with concurrent changes of the on-ledger package vetting state.
	//
	// Required
	PackageReferences []*v2.PackageReference `protobuf:"bytes,1,rep,name=package_references,json=packageReferences,proto3" json:"package_references,omitempty"`
	// The synchronizer for which the package preferences are computed.
	// If the synchronizer_id was specified in the request, then it matches the request synchronizer_id.
	// Required
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// contains filtered or unexported fields
}

type GlobalKey struct {

	// The identifier uses the package-id reference format.
	TemplateId  *v2.Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	PackageName string         `protobuf:"bytes,2,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	Key         *v2.Value      `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Hash        []byte         `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"`
	// contains filtered or unexported fields
}

type HashingSchemeVersion int32

type InteractiveSubmissionServiceClient interface {
	// Requires `readAs` scope for the submitting party when LAPI User authorization is enabled
	PrepareSubmission(ctx context.Context, in *PrepareSubmissionRequest, opts ...grpc.CallOption) (*PrepareSubmissionResponse, error)
	// Execute a prepared submission _asynchronously_ on the ledger.
	// Requires a signature of the transaction from the submitting external party.
	ExecuteSubmission(ctx context.Context, in *ExecuteSubmissionRequest, opts ...grpc.CallOption) (*ExecuteSubmissionResponse, error)
	// Similar to ExecuteSubmission but _synchronously_ wait for the completion of the transaction
	// IMPORTANT: Relying on the response from this endpoint requires trusting the Participant Node to be honest.
	// A malicious node could make a successfully committed request appeared failed and vice versa
	ExecuteSubmissionAndWait(ctx context.Context, in *ExecuteSubmissionAndWaitRequest, opts ...grpc.CallOption) (*ExecuteSubmissionAndWaitResponse, error)
	// Similar to ExecuteSubmissionAndWait but additionally returns the transaction
	// IMPORTANT: Relying on the response from this endpoint requires trusting the Participant Node to be honest.
	// A malicious node could make a successfully committed request appear as failed and vice versa
	ExecuteSubmissionAndWaitForTransaction(ctx context.Context, in *ExecuteSubmissionAndWaitForTransactionRequest, opts ...grpc.CallOption) (*ExecuteSubmissionAndWaitForTransactionResponse, error)
	// A preferred package is the highest-versioned package for a provided package-name
	// that is vetted by all the participants hosting the provided parties.
	//
	// Ledger API clients should use this endpoint for constructing command submissions
	// that are compatible with the provided preferred package, by making informed decisions on:
	// - which are the compatible packages that can be used to create contracts
	// - which contract or exercise choice argument version can be used in the command
	// - which choices can be executed on a template or interface of a contract
	//
	// Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
	//
	// Provided for backwards compatibility, it will be removed in the Canton version 3.4.0
	GetPreferredPackageVersion(ctx context.Context, in *GetPreferredPackageVersionRequest, opts ...grpc.CallOption) (*GetPreferredPackageVersionResponse, error)
	// Compute the preferred packages for the vetting requirements in the request.
	// A preferred package is the highest-versioned package for a provided package-name
	// that is vetted by all the participants hosting the provided parties.
	//
	// Ledger API clients should use this endpoint for constructing command submissions
	// that are compatible with the provided preferred packages, by making informed decisions on:
	// - which are the compatible packages that can be used to create contracts
	// - which contract or exercise choice argument version can be used in the command
	// - which choices can be executed on a template or interface of a contract
	//
	// If the package preferences could not be computed due to no selection satisfying the requirements,
	// a `FAILED_PRECONDITION` error will be returned.
	//
	// Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
	//
	// Experimental API: this endpoint is not guaranteed to provide backwards compatibility in future releases
	GetPreferredPackages(ctx context.Context, in *GetPreferredPackagesRequest, opts ...grpc.CallOption) (*GetPreferredPackagesResponse, error)
}

type InteractiveSubmissionServiceServer interface {
	// Requires `readAs` scope for the submitting party when LAPI User authorization is enabled
	PrepareSubmission(context.Context, *PrepareSubmissionRequest) (*PrepareSubmissionResponse, error)
	// Execute a prepared submission _asynchronously_ on the ledger.
	// Requires a signature of the transaction from the submitting external party.
	ExecuteSubmission(context.Context, *ExecuteSubmissionRequest) (*ExecuteSubmissionResponse, error)
	// Similar to ExecuteSubmission but _synchronously_ wait for the completion of the transaction
	// IMPORTANT: Relying on the response from this endpoint requires trusting the Participant Node to be honest.
	// A malicious node could make a successfully committed request appeared failed and vice versa
	ExecuteSubmissionAndWait(context.Context, *ExecuteSubmissionAndWaitRequest) (*ExecuteSubmissionAndWaitResponse, error)
	// Similar to ExecuteSubmissionAndWait but additionally returns the transaction
	// IMPORTANT: Relying on the response from this endpoint requires trusting the Participant Node to be honest.
	// A malicious node could make a successfully committed request appear as failed and vice versa
	ExecuteSubmissionAndWaitForTransaction(context.Context, *ExecuteSubmissionAndWaitForTransactionRequest) (*ExecuteSubmissionAndWaitForTransactionResponse, error)
	// A preferred package is the highest-versioned package for a provided package-name
	// that is vetted by all the participants hosting the provided parties.
	//
	// Ledger API clients should use this endpoint for constructing command submissions
	// that are compatible with the provided preferred package, by making informed decisions on:
	// - which are the compatible packages that can be used to create contracts
	// - which contract or exercise choice argument version can be used in the command
	// - which choices can be executed on a template or interface of a contract
	//
	// Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
	//
	// Provided for backwards compatibility, it will be removed in the Canton version 3.4.0
	GetPreferredPackageVersion(context.Context, *GetPreferredPackageVersionRequest) (*GetPreferredPackageVersionResponse, error)
	// Compute the preferred packages for the vetting requirements in the request.
	// A preferred package is the highest-versioned package for a provided package-name
	// that is vetted by all the participants hosting the provided parties.
	//
	// Ledger API clients should use this endpoint for constructing command submissions
	// that are compatible with the provided preferred packages, by making informed decisions on:
	// - which are the compatible packages that can be used to create contracts
	// - which contract or exercise choice argument version can be used in the command
	// - which choices can be executed on a template or interface of a contract
	//
	// If the package preferences could not be computed due to no selection satisfying the requirements,
	// a `FAILED_PRECONDITION` error will be returned.
	//
	// Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
	//
	// Experimental API: this endpoint is not guaranteed to provide backwards compatibility in future releases
	GetPreferredPackages(context.Context, *GetPreferredPackagesRequest) (*GetPreferredPackagesResponse, error)
	// contains filtered or unexported methods
}

type Metadata struct {
	SubmitterInfo   *Metadata_SubmitterInfo   `protobuf:"bytes,2,opt,name=submitter_info,json=submitterInfo,proto3" json:"submitter_info,omitempty"`
	SynchronizerId  string                    `protobuf:"bytes,3,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	MediatorGroup   uint32                    `protobuf:"varint,4,opt,name=mediator_group,json=mediatorGroup,proto3" json:"mediator_group,omitempty"`
	TransactionUuid string                    `protobuf:"bytes,5,opt,name=transaction_uuid,json=transactionUuid,proto3" json:"transaction_uuid,omitempty"`
	PreparationTime uint64                    `protobuf:"varint,6,opt,name=preparation_time,json=preparationTime,proto3" json:"preparation_time,omitempty"`
	InputContracts  []*Metadata_InputContract `protobuf:"bytes,7,rep,name=input_contracts,json=inputContracts,proto3" json:"input_contracts,omitempty"`
	// Where ledger time constraints are imposed during the execution of the contract they will be populated
	// in the fields below. These are optional because if the transaction does NOT depend on time, these values
	// do not need to be set.
	// The final ledger effective time used will be chosen when the command is submitted through the [execute] RPC.
	// If the ledger effective time is outside of any populated min/max bounds then a different transaction
	// can result, that will cause a confirmation message rejection.
	MinLedgerEffectiveTime *uint64 `` /* 138-byte string literal not displayed */
	MaxLedgerEffectiveTime *uint64 `` /* 139-byte string literal not displayed */
	// Contextual information needed to process the transaction but not signed, either because it's already indirectly
	// signed by signing the transaction, or because it doesn't impact the ledger state
	GlobalKeyMapping []*Metadata_GlobalKeyMappingEntry `protobuf:"bytes,8,rep,name=global_key_mapping,json=globalKeyMapping,proto3" json:"global_key_mapping,omitempty"`
	// Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer `synchronizer_id`.
	// 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.
	// Unsigned in 3.3 to avoid a breaking protocol change
	// Will be signed in 3.4+
	// Set max_record_time in the PreparedTransactionRequest to get this field set accordingly
	MaxRecordTime *uint64 `protobuf:"varint,11,opt,name=max_record_time,json=maxRecordTime,proto3,oneof" json:"max_record_time,omitempty"`
	// contains filtered or unexported fields
}

type Metadata_GlobalKeyMappingEntry struct {
	Key   *GlobalKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value *v2.Value  `protobuf:"bytes,2,opt,name=value,proto3,oneof" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Metadata_InputContract struct {

	// Types that are valid to be assigned to Contract:
	//
	//	*Metadata_InputContract_V1
	Contract  isMetadata_InputContract_Contract `protobuf_oneof:"contract"`
	CreatedAt uint64                            `protobuf:"varint,1000,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	EventBlob []byte                            `protobuf:"bytes,1002,opt,name=event_blob,json=eventBlob,proto3" json:"event_blob,omitempty"`
	// contains filtered or unexported fields
}

type Metadata_InputContract_V1 struct {
	// When new versions will be added, they will show here
	V1 *v1.Create `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type Metadata_SubmitterInfo struct {
	ActAs     []string `protobuf:"bytes,1,rep,name=act_as,json=actAs,proto3" json:"act_as,omitempty"`
	CommandId string   `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// contains filtered or unexported fields
}

type MinLedgerTime struct {

	// Types that are valid to be assigned to Time:
	//
	//	*MinLedgerTime_MinLedgerTimeAbs
	//	*MinLedgerTime_MinLedgerTimeRel
	Time isMinLedgerTime_Time `protobuf_oneof:"time"`
	// contains filtered or unexported fields
}

type MinLedgerTime_MinLedgerTimeAbs struct {
	// Lower bound for the ledger time assigned to the resulting transaction.
	// The ledger time of a transaction is assigned as part of command interpretation.
	// Important note: for interactive submissions, if the transaction depends on time, it **must** be signed
	// and submitted within a time window around the ledger time assigned to the transaction during the prepare method.
	// The time delta around that ledger time is a configuration of the ledger, usually short, around 1 minute.
	// If however the transaction does not depend on time, the available time window to sign and submit the transaction is bound
	// by the preparation time, which is also assigned in the "prepare" step (this request),
	// but can be configured with a much larger skew, allowing for more time to sign the request (in the order of hours).
	// Must not be set at the same time as min_ledger_time_rel.
	// Optional
	MinLedgerTimeAbs *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=min_ledger_time_abs,json=minLedgerTimeAbs,proto3,oneof"`
}

type MinLedgerTime_MinLedgerTimeRel struct {
	// Same as min_ledger_time_abs, but specified as a duration, starting from the time this request is received by the server.
	// Must not be set at the same time as min_ledger_time_abs.
	// Optional
	MinLedgerTimeRel *durationpb.Duration `protobuf:"bytes,2,opt,name=min_ledger_time_rel,json=minLedgerTimeRel,proto3,oneof"`
}

type PackagePreference struct {

	// The package reference of the preferred package.
	// Required
	PackageReference *v2.PackageReference `protobuf:"bytes,1,opt,name=package_reference,json=packageReference,proto3" json:"package_reference,omitempty"`
	// The synchronizer for which the preferred package was computed.
	// If the synchronizer_id was specified in the request, then it matches the request synchronizer_id.
	// Required
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// contains filtered or unexported fields
}

type PackageVettingRequirement struct {

	// The parties whose participants' vetting state should be considered when resolving the preferred package.
	// Required
	Parties []string `protobuf:"bytes,1,rep,name=parties,proto3" json:"parties,omitempty"`
	// The package-name for which the preferred package should be resolved.
	// Required
	PackageName string `protobuf:"bytes,2,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// contains filtered or unexported fields
}

type PartySignatures struct {

	// Additional signatures provided by all individual parties
	// Required
	Signatures []*SinglePartySignatures `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
	// contains filtered or unexported fields
}

type PrepareSubmissionRequest struct {

	// 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
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// 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
	CommandId string `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// 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
	Commands []*v2.Command `protobuf:"bytes,3,rep,name=commands,proto3" json:"commands,omitempty"`
	// Optional
	MinLedgerTime *MinLedgerTime `protobuf:"bytes,4,opt,name=min_ledger_time,json=minLedgerTime,proto3" json:"min_ledger_time,omitempty"`
	// 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
	MaxRecordTime *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=max_record_time,json=maxRecordTime,proto3,oneof" json:"max_record_time,omitempty"`
	// 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.
	ActAs []string `protobuf:"bytes,5,rep,name=act_as,json=actAs,proto3" json:"act_as,omitempty"`
	// 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
	ReadAs []string `protobuf:"bytes,6,rep,name=read_as,json=readAs,proto3" json:"read_as,omitempty"`
	// Additional contracts used to resolve contract & contract key lookups.
	// Optional
	DisclosedContracts []*v2.DisclosedContract `protobuf:"bytes,7,rep,name=disclosed_contracts,json=disclosedContracts,proto3" json:"disclosed_contracts,omitempty"`
	// Must be a valid synchronizer id
	// If not set, a suitable synchronizer that this node is connected to will be chosen
	// Optional
	SynchronizerId string `protobuf:"bytes,8,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// The package-id selection preference of the client for resolving
	// package names and interface instances in command submission and interpretation
	// Optional
	PackageIdSelectionPreference []string `` /* 149-byte string literal not displayed */
	// 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.
	// Optional, default to false
	VerboseHashing bool `protobuf:"varint,10,opt,name=verbose_hashing,json=verboseHashing,proto3" json:"verbose_hashing,omitempty"`
	// 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
	PrefetchContractKeys []*v2.PrefetchContractKey `protobuf:"bytes,15,rep,name=prefetch_contract_keys,json=prefetchContractKeys,proto3" json:"prefetch_contract_keys,omitempty"`
	// 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.
	//
	// Optional - 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
	EstimateTrafficCost *CostEstimationHints `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type PrepareSubmissionResponse struct {

	// The interpreted transaction, it represents the ledger changes necessary to execute the commands specified in the request.
	// Clients MUST display the content of the transaction to the user for them to validate before signing the hash if the preparing participant is not trusted.
	PreparedTransaction *PreparedTransaction `protobuf:"bytes,1,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	// Hash of the transaction, this is what needs to be signed by the party to authorize the transaction.
	// Only provided for convenience, clients MUST recompute the hash from the raw transaction if the preparing participant is not trusted.
	// May be removed in future versions
	PreparedTransactionHash []byte `` /* 132-byte string literal not displayed */
	// The hashing scheme version used when building the hash
	HashingSchemeVersion HashingSchemeVersion `` /* 185-byte string literal not displayed */
	// Optional additional details on how the transaction was encoded and hashed. Only set if verbose_hashing = true in the request
	// Note that there are no guarantees on the stability of the format or content of this field.
	// Its content should NOT be parsed and should only be used for troubleshooting purposes.
	HashingDetails *string `protobuf:"bytes,4,opt,name=hashing_details,json=hashingDetails,proto3,oneof" json:"hashing_details,omitempty"`
	// Traffic cost estimation of the prepared transaction
	// Optional
	CostEstimation *CostEstimation `protobuf:"bytes,5,opt,name=cost_estimation,json=costEstimation,proto3,oneof" json:"cost_estimation,omitempty"`
	// contains filtered or unexported fields
}

type PreparedTransaction struct {

	// Daml Transaction representing the ledger effect if executed. See below
	Transaction *DamlTransaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// Metadata context necessary to execute the transaction
	Metadata *Metadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type SinglePartySignatures struct {

	// Submitting party
	// Required
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// Signatures
	// Required
	Signatures []*v2.Signature `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedInteractiveSubmissionServiceServer struct{}

type UnsafeInteractiveSubmissionServiceServer interface {
	// contains filtered or unexported methods
}