types

type AccessPath struct {
	Address              []byte   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Path                 []byte   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AccountState struct {
	// Account address
	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Account state blob
	Blob                 []byte   `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AccountStateBlob struct {
	Blob                 []byte   `protobuf:"bytes,1,opt,name=blob,proto3" json:"blob,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AccountStateProof struct {
	LedgerInfoToTransactionInfoProof *AccumulatorProof  `` /* 165-byte string literal not displayed */
	TransactionInfo                  *TransactionInfo   `protobuf:"bytes,2,opt,name=transaction_info,json=transactionInfo,proto3" json:"transaction_info,omitempty"`
	TransactionInfoToAccountProof    *SparseMerkleProof `` /* 154-byte string literal not displayed */
	XXX_NoUnkeyedLiteral             struct{}           `json:"-"`
	XXX_unrecognized                 []byte             `json:"-"`
	XXX_sizecache                    int32              `json:"-"`
}

type AccountStateWithProof struct {
	Version              uint64             `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Blob                 *AccountStateBlob  `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
	Proof                *AccountStateProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

type AccumulatorConsistencyProof struct {
	// The root hashes of the subtrees that represent new leaves. Note that none
	// of these hashes should be default hash.
	Subtrees             [][]byte `protobuf:"bytes,1,rep,name=subtrees,proto3" json:"subtrees,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AccumulatorProof struct {
	// The siblings. The ones near the leaf are at the beginning of the list. The
	// placeholder nodes are represented by empty byte arrays, other nodes should
	// be exactly 32-bytes long.
	Siblings             [][]byte `protobuf:"bytes,1,rep,name=siblings,proto3" json:"siblings,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AccumulatorRangeProof struct {
	// The siblings on the left of the path from root to the first leaf. The ones
	// near the leaf are at the beginning of the list. The placeholder nodes are
	// represented by empty byte arrays, other nodes should be exactly 32-bytes
	// long.
	LeftSiblings [][]byte `protobuf:"bytes,1,rep,name=left_siblings,json=leftSiblings,proto3" json:"left_siblings,omitempty"`
	// The siblings on the right of the path from root to the last leaf. The ones
	// near the leaf are at the beginning of the list. The placeholder nodes are
	// represented by empty byte arrays, other nodes should be exactly 32-bytes
	// long.
	RightSiblings        [][]byte `protobuf:"bytes,2,rep,name=right_siblings,json=rightSiblings,proto3" json:"right_siblings,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Event struct {
	Key                  []byte   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	SequenceNumber       uint64   `protobuf:"varint,2,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	EventData            []byte   `protobuf:"bytes,3,opt,name=event_data,json=eventData,proto3" json:"event_data,omitempty"`
	TypeTag              []byte   `protobuf:"bytes,4,opt,name=type_tag,json=typeTag,proto3" json:"type_tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type EventProof struct {
	LedgerInfoToTransactionInfoProof *AccumulatorProof `` /* 165-byte string literal not displayed */
	TransactionInfo                  *TransactionInfo  `protobuf:"bytes,2,opt,name=transaction_info,json=transactionInfo,proto3" json:"transaction_info,omitempty"`
	TransactionInfoToEventProof      *AccumulatorProof `` /* 148-byte string literal not displayed */
	XXX_NoUnkeyedLiteral             struct{}          `json:"-"`
	XXX_unrecognized                 []byte            `json:"-"`
	XXX_sizecache                    int32             `json:"-"`
}

type EventWithProof struct {
	TransactionVersion   uint64      `protobuf:"varint,1,opt,name=transaction_version,json=transactionVersion,proto3" json:"transaction_version,omitempty"`
	EventIndex           uint64      `protobuf:"varint,2,opt,name=event_index,json=eventIndex,proto3" json:"event_index,omitempty"`
	Event                *Event      `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
	Proof                *EventProof `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type EventsForVersions struct {
	EventsForVersion     []*EventsList `protobuf:"bytes,1,rep,name=events_for_version,json=eventsForVersion,proto3" json:"events_for_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

type EventsList struct {
	Events               []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type GetAccountStateRequest struct {
	// Account for which we are fetching the state.
	Address              []byte   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type GetAccountStateResponse struct {
	// Blob value representing the account state together with proof the client
	// can utilize to verify it.
	AccountStateWithProof *AccountStateWithProof `` /* 128-byte string literal not displayed */
	XXX_NoUnkeyedLiteral  struct{}               `json:"-"`
	XXX_unrecognized      []byte                 `json:"-"`
	XXX_sizecache         int32                  `json:"-"`
}

type GetAccountTransactionBySequenceNumberRequest struct {
	// Account for which to query transactions
	Account        []byte `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	SequenceNumber uint64 `protobuf:"varint,2,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// Set to true to fetch events for the transaction at this version
	FetchEvents          bool     `protobuf:"varint,3,opt,name=fetch_events,json=fetchEvents,proto3" json:"fetch_events,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type GetAccountTransactionBySequenceNumberResponse struct {
	// When the transaction requested is committed, return the committed
	// transaction with proof.
	TransactionWithProof *TransactionWithProof `protobuf:"bytes,2,opt,name=transaction_with_proof,json=transactionWithProof,proto3" json:"transaction_with_proof,omitempty"`
	// When the transaction requested is not committed, we give a proof that
	// shows the current sequence number is smaller than what would have been if
	// the transaction was committed.
	ProofOfCurrentSequenceNumber *AccountStateWithProof `` /* 151-byte string literal not displayed */
	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
	XXX_unrecognized             []byte                 `json:"-"`
	XXX_sizecache                int32                  `json:"-"`
}

type GetEventsByEventAccessPathRequest struct {
	AccessPath *AccessPath `protobuf:"bytes,1,opt,name=access_path,json=accessPath,proto3" json:"access_path,omitempty"`
	// The sequence number of the event to start with for this query. Use a
	// sequence number of MAX_INT to represent the latest.
	StartEventSeqNum uint64 `protobuf:"varint,2,opt,name=start_event_seq_num,json=startEventSeqNum,proto3" json:"start_event_seq_num,omitempty"`
	// If ascending is true this query will return up to `limit` events that were
	// emitted after `start_event_seq_num`. Otherwise it will return up to `limit`
	// events before the offset. Both cases are inclusive.
	Ascending bool `protobuf:"varint,3,opt,name=ascending,proto3" json:"ascending,omitempty"`
	// Limit number of results
	Limit                uint64   `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type GetEventsByEventAccessPathResponse struct {
	// Returns an event and proof of each of the events in the request. The first
	// element of proofs will be the closest to `start_event_seq_num`.
	EventsWithProof []*EventWithProof `protobuf:"bytes,1,rep,name=events_with_proof,json=eventsWithProof,proto3" json:"events_with_proof,omitempty"`
	// If the number of events returned is less than `limit` for an ascending
	// query or if start_event_seq_num > the latest seq_num for a descending
	// query, returns the state of the account containing the given access path
	// in the latest state. This allows the client to verify that there are in
	// fact no extra events.
	//
	// The LedgerInfoWithSignatures which is on the main
	// UpdateToLatestLedgerResponse can be used to validate this.
	ProofOfLatestEvent   *AccountStateWithProof `protobuf:"bytes,2,opt,name=proof_of_latest_event,json=proofOfLatestEvent,proto3" json:"proof_of_latest_event,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

type GetTransactionsRequest struct {
	// The version of the transaction to start with for this query.  Use a version
	// of MAX_INT to represent the latest.
	StartVersion uint64 `protobuf:"varint,1,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"`
	// Limit number of results
	Limit uint64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Set to true to fetch events for the transaction at each version
	FetchEvents          bool     `protobuf:"varint,3,opt,name=fetch_events,json=fetchEvents,proto3" json:"fetch_events,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type GetTransactionsResponse struct {
	TxnListWithProof     *TransactionListWithProof `protobuf:"bytes,1,opt,name=txn_list_with_proof,json=txnListWithProof,proto3" json:"txn_list_with_proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

type LedgerInfo struct {
	// Current latest version of the system
	Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// Root hash of transaction accumulator at this version
	TransactionAccumulatorHash []byte `` /* 141-byte string literal not displayed */
	// Hash of consensus-specific data that is opaque to all parts of the system
	// other than consensus.  This is needed to verify signatures because
	// consensus signing includes this hash
	ConsensusDataHash []byte `protobuf:"bytes,3,opt,name=consensus_data_hash,json=consensusDataHash,proto3" json:"consensus_data_hash,omitempty"`
	// The block id of the last committed block corresponding to this ledger info.
	// This field is not particularly interesting to the clients, but can be used
	// by the validators for synchronization.
	ConsensusBlockId []byte `protobuf:"bytes,4,opt,name=consensus_block_id,json=consensusBlockId,proto3" json:"consensus_block_id,omitempty"`
	// Epoch number corresponds to the set of validators that are active for this
	// ledger info. The main motivation for keeping the epoch number in the
	// LedgerInfo is to ensure that the client has enough information to verify
	// that the signatures for this info are coming from the validators that
	// indeed form a quorum. Without epoch number a potential attack could reuse
	// the signatures from the validators in one epoch in order to sign the wrong
	// info belonging to another epoch, in which these validators do not form a
	// quorum. The very first epoch number is 0.
	Epoch uint64 `protobuf:"varint,5,opt,name=epoch,proto3" json:"epoch,omitempty"`
	// Consensus protocol operates in rounds: the number corresponds to the
	// proposal round of a given commit. Not relevant to the clients, but can be
	// used by the validators for synchronization.
	Round uint64 `protobuf:"varint,6,opt,name=round,proto3" json:"round,omitempty"`
	// Timestamp that represents the microseconds since the epoch (unix time) that
	// is generated by the proposer of the block.  This is strictly increasing
	// with every block. If a client reads a timestamp > the one they specified
	// for transaction expiration time, they can be certain that their transaction
	// will never be included in a block in the future (assuming that their
	// transaction has not yet been included)
	TimestampUsecs uint64 `protobuf:"varint,7,opt,name=timestamp_usecs,json=timestampUsecs,proto3" json:"timestamp_usecs,omitempty"`
	// An optional field with the validator set for the next epoch in case it's
	// the last ledger info in the current epoch.
	NextValidatorSet     *ValidatorSet `protobuf:"bytes,8,opt,name=next_validator_set,json=nextValidatorSet,proto3" json:"next_validator_set,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

type LedgerInfoWithSignatures struct {
	// Signatures of the root node from each validator
	Signatures           []*ValidatorSignature `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
	LedgerInfo           *LedgerInfo           `protobuf:"bytes,2,opt,name=ledger_info,json=ledgerInfo,proto3" json:"ledger_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

type ModuleId struct {
	Address              []byte   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type RequestItem struct {
	// Types that are valid to be assigned to RequestedItems:
	//	*RequestItem_GetAccountStateRequest
	//	*RequestItem_GetAccountTransactionBySequenceNumberRequest
	//	*RequestItem_GetEventsByEventAccessPathRequest
	//	*RequestItem_GetTransactionsRequest
	RequestedItems       isRequestItem_RequestedItems `protobuf_oneof:"requested_items"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

type RequestItem_GetAccountStateRequest struct {
	GetAccountStateRequest *GetAccountStateRequest `protobuf:"bytes,1,opt,name=get_account_state_request,json=getAccountStateRequest,proto3,oneof"`
}

type RequestItem_GetAccountTransactionBySequenceNumberRequest struct {
	GetAccountTransactionBySequenceNumberRequest *GetAccountTransactionBySequenceNumberRequest `` /* 141-byte string literal not displayed */
}

type RequestItem_GetEventsByEventAccessPathRequest struct {
	GetEventsByEventAccessPathRequest *GetEventsByEventAccessPathRequest `protobuf:"bytes,3,opt,name=get_events_by_event_access_path_request,json=getEventsByEventAccessPathRequest,proto3,oneof"`
}

type RequestItem_GetTransactionsRequest struct {
	GetTransactionsRequest *GetTransactionsRequest `protobuf:"bytes,4,opt,name=get_transactions_request,json=getTransactionsRequest,proto3,oneof"`
}

type ResponseItem struct {
	// Types that are valid to be assigned to ResponseItems:
	//	*ResponseItem_GetAccountStateResponse
	//	*ResponseItem_GetAccountTransactionBySequenceNumberResponse
	//	*ResponseItem_GetEventsByEventAccessPathResponse
	//	*ResponseItem_GetTransactionsResponse
	ResponseItems        isResponseItem_ResponseItems `protobuf_oneof:"response_items"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

type ResponseItem_GetAccountStateResponse struct {
	GetAccountStateResponse *GetAccountStateResponse `protobuf:"bytes,3,opt,name=get_account_state_response,json=getAccountStateResponse,proto3,oneof"`
}

type ResponseItem_GetAccountTransactionBySequenceNumberResponse struct {
	GetAccountTransactionBySequenceNumberResponse *GetAccountTransactionBySequenceNumberResponse `` /* 143-byte string literal not displayed */
}

type ResponseItem_GetEventsByEventAccessPathResponse struct {
	GetEventsByEventAccessPathResponse *GetEventsByEventAccessPathResponse `protobuf:"bytes,5,opt,name=get_events_by_event_access_path_response,json=getEventsByEventAccessPathResponse,proto3,oneof"`
}

type ResponseItem_GetTransactionsResponse struct {
	GetTransactionsResponse *GetTransactionsResponse `protobuf:"bytes,6,opt,name=get_transactions_response,json=getTransactionsResponse,proto3,oneof"`
}

type SignedTransaction struct {
	// LCS bytes representation of a SignedTransaction.
	TxnBytes             []byte   `protobuf:"bytes,5,opt,name=txn_bytes,json=txnBytes,proto3" json:"txn_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type SignedTransactionsBlock struct {
	// Set of Signed Transactions
	Transactions []*SignedTransaction `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"`
	// Public key of the validator that created this block
	ValidatorPublicKey []byte `protobuf:"bytes,2,opt,name=validator_public_key,json=validatorPublicKey,proto3" json:"validator_public_key,omitempty"`
	// Signature of the validator that created this block
	ValidatorSignature   []byte   `protobuf:"bytes,3,opt,name=validator_signature,json=validatorSignature,proto3" json:"validator_signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type SparseMerkleProof struct {
	// This proof can be used to authenticate whether a given leaf exists in the
	// tree or not. In Rust:
	//   - If this is `Some(HashValue, HashValue)`
	//     - If the first `HashValue` equals requested key, this is an inclusion
	//       proof and the second `HashValue` equals the hash of the
	//       corresponding account blob.
	//     - Otherwise this is a non-inclusion proof. The first `HashValue` is
	//       the only key that exists in the subtree and the second `HashValue`
	//       equals the hash of the corresponding account blob.
	//   - If this is `None`, this is also a non-inclusion proof which indicates
	//     the subtree is empty.
	//
	// In protobuf, this leaf field should either be
	//   - empty, which corresponds to None in the Rust structure.
	//   - exactly 64 bytes, which corresponds to Some<(HashValue, HashValue)>
	//     in the Rust structure.
	Leaf []byte `protobuf:"bytes,1,opt,name=leaf,proto3" json:"leaf,omitempty"`
	// The siblings. The ones near the leaf are at the beginning of the list. The
	// placeholder nodes are represented by empty byte arrays, other nodes should
	// be exactly 32-bytes long.
	Siblings             [][]byte `protobuf:"bytes,2,rep,name=siblings,proto3" json:"siblings,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type SparseMerkleRangeProof struct {
	// The siblings on the right of the path from root to the last leaf. The ones
	// near the leaf are at the beginning of the list. The placeholder nodes are
	// represented by empty byte arrays, other nodes should be exactly 32-bytes
	// long.
	RightSiblings        [][]byte `protobuf:"bytes,1,rep,name=right_siblings,json=rightSiblings,proto3" json:"right_siblings,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Transaction struct {
	Transaction          []byte   `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TransactionArgument struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TransactionArgument_ArgType int32

type TransactionInfo struct {
	// Hash of the transaction that is stored.
	TransactionHash []byte `protobuf:"bytes,1,opt,name=transaction_hash,json=transactionHash,proto3" json:"transaction_hash,omitempty"`
	// The root hash of Sparse Merkle Tree describing the world state at the end
	// of this transaction
	StateRootHash []byte `protobuf:"bytes,2,opt,name=state_root_hash,json=stateRootHash,proto3" json:"state_root_hash,omitempty"`
	// The root hash of Merkle Accumulator storing all events emitted during this
	// transaction.
	EventRootHash []byte `protobuf:"bytes,3,opt,name=event_root_hash,json=eventRootHash,proto3" json:"event_root_hash,omitempty"`
	// The amount of gas used by this transaction.
	GasUsed uint64 `protobuf:"varint,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
	// The major status of executing this transaction.
	MajorStatus          uint64   `protobuf:"varint,5,opt,name=major_status,json=majorStatus,proto3" json:"major_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TransactionListProof struct {
	LedgerInfoToTransactionInfosProof *AccumulatorRangeProof `` /* 168-byte string literal not displayed */
	TransactionInfos                  []*TransactionInfo     `protobuf:"bytes,2,rep,name=transaction_infos,json=transactionInfos,proto3" json:"transaction_infos,omitempty"`
	XXX_NoUnkeyedLiteral              struct{}               `json:"-"`
	XXX_unrecognized                  []byte                 `json:"-"`
	XXX_sizecache                     int32                  `json:"-"`
}

type TransactionListWithProof struct {
	// The list of transactions.
	Transactions []*Transaction `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"`
	// The list of corresponding Event objects (only present if fetch_events was
	// set to true in req)
	EventsForVersions *EventsForVersions `protobuf:"bytes,2,opt,name=events_for_versions,json=eventsForVersions,proto3" json:"events_for_versions,omitempty"`
	// If the list is not empty, the version of the first transaction.
	FirstTransactionVersion *wrappers.UInt64Value `` /* 132-byte string literal not displayed */
	// The proof authenticating the transactions and events.When this is used
	// for state synchronization, the validator who requests the transactions
	// will provide a version in the request and the proofs will be relative to
	// the given version. When this is returned in GetTransactionsResponse, the
	// proofs will be relative to the ledger info returned in
	// UpdateToLatestLedgerResponse.
	Proof                *TransactionListProof `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

type TransactionProof struct {
	LedgerInfoToTransactionInfoProof *AccumulatorProof `` /* 165-byte string literal not displayed */
	TransactionInfo                  *TransactionInfo  `protobuf:"bytes,2,opt,name=transaction_info,json=transactionInfo,proto3" json:"transaction_info,omitempty"`
	XXX_NoUnkeyedLiteral             struct{}          `json:"-"`
	XXX_unrecognized                 []byte            `json:"-"`
	XXX_sizecache                    int32             `json:"-"`
}

type TransactionToCommit struct {
	// The signed transaction which was executed
	Transaction *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// State db updates
	AccountStates []*AccountState `protobuf:"bytes,2,rep,name=account_states,json=accountStates,proto3" json:"account_states,omitempty"`
	// Events yielded by the transaction.
	Events []*Event `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"`
	// The amount of gas used.
	GasUsed uint64 `protobuf:"varint,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
	// The major status of executing the transaction.
	MajorStatus          uint64   `protobuf:"varint,5,opt,name=major_status,json=majorStatus,proto3" json:"major_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TransactionWithProof struct {
	// The version of the returned signed transaction.
	Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// The transaction itself.
	Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// The proof authenticating the transaction.
	Proof *TransactionProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
	// The events yielded by executing the transaction, if requested.
	Events               *EventsList `protobuf:"bytes,4,opt,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type UpdateToLatestLedgerRequest struct {
	// This is the version the client already trusts. Usually the client should
	// set this to the version it obtained the last time it synced with the
	// chain. If this is the first time ever the client sends a request, it must
	// use the waypoint hard-coded in its software.
	ClientKnownVersion uint64 `protobuf:"varint,1,opt,name=client_known_version,json=clientKnownVersion,proto3" json:"client_known_version,omitempty"`
	// The items for which we are requesting data in this API call.
	RequestedItems       []*RequestItem `protobuf:"bytes,2,rep,name=requested_items,json=requestedItems,proto3" json:"requested_items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

type UpdateToLatestLedgerResponse struct {
	// Responses to the queries posed by the requests. The proofs generated will
	// be relative to the version of the latest ledger provided below.
	ResponseItems []*ResponseItem `protobuf:"bytes,1,rep,name=response_items,json=responseItems,proto3" json:"response_items,omitempty"`
	// The latest ledger info this node has. It will come with at least 2f+1
	// validator signatures as well as a proof that shows the latest ledger
	// extends the old ledger the client had.
	LedgerInfoWithSigs *LedgerInfoWithSignatures `protobuf:"bytes,2,opt,name=ledger_info_with_sigs,json=ledgerInfoWithSigs,proto3" json:"ledger_info_with_sigs,omitempty"`
	// A proof for Validator changes from what the client last knew. This is
	// used to inform the client of validator changes from the client's last
	// known version until the current version.
	ValidatorChangeProof *ValidatorChangeProof `protobuf:"bytes,3,opt,name=validator_change_proof,json=validatorChangeProof,proto3" json:"validator_change_proof,omitempty"`
	// A proof that shows the latest ledger accumulator is consistent with the
	// old accumulator at "client_known_version".
	LedgerConsistencyProof *AccumulatorConsistencyProof `` /* 129-byte string literal not displayed */
	XXX_NoUnkeyedLiteral   struct{}                     `json:"-"`
	XXX_unrecognized       []byte                       `json:"-"`
	XXX_sizecache          int32                        `json:"-"`
}

type VMStatus struct {
	// e.g. assertion violation, out of gas
	MajorStatus uint64 `protobuf:"varint,1,opt,name=major_status,json=majorStatus,proto3" json:"major_status,omitempty"`
	// Any substatus code. e.g. assertion error number
	HasSubStatus         bool     `protobuf:"varint,2,opt,name=has_sub_status,json=hasSubStatus,proto3" json:"has_sub_status,omitempty"`
	SubStatus            uint64   `protobuf:"varint,3,opt,name=sub_status,json=subStatus,proto3" json:"sub_status,omitempty"`
	HasMessage           bool     `protobuf:"varint,4,opt,name=has_message,json=hasMessage,proto3" json:"has_message,omitempty"`
	Message              string   `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ValidatorChangeProof struct {
	// A list of LedgerInfos with contiguous increasing epoch numbers.
	LedgerInfoWithSigs []*LedgerInfoWithSignatures `protobuf:"bytes,1,rep,name=ledger_info_with_sigs,json=ledgerInfoWithSigs,proto3" json:"ledger_info_with_sigs,omitempty"`
	// A flag (when true) that indicates the above list is incomplete and only
	// contains the first N epoch changes.
	More                 bool     `protobuf:"varint,2,opt,name=more,proto3" json:"more,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ValidatorPublicKeys struct {
	// Validator account address
	AccountAddress []byte `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
	// Consensus public key
	ConsensusPublicKey []byte `protobuf:"bytes,2,opt,name=consensus_public_key,json=consensusPublicKey,proto3" json:"consensus_public_key,omitempty"`
	// Validator voting power for consensus
	ConsensusVotingPower uint64 `protobuf:"varint,3,opt,name=consensus_voting_power,json=consensusVotingPower,proto3" json:"consensus_voting_power,omitempty"`
	// Network signing publick key
	NetworkSigningPublicKey []byte `` /* 134-byte string literal not displayed */
	/// Network identity publick key
	NetworkIdentityPublicKey []byte   `` /* 137-byte string literal not displayed */
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_unrecognized         []byte   `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

type ValidatorSet struct {
	ValidatorPublicKeys  []*ValidatorPublicKeys `protobuf:"bytes,1,rep,name=validator_public_keys,json=validatorPublicKeys,proto3" json:"validator_public_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

type ValidatorSignature struct {
	// The account address of the validator, which can be used for retrieving its
	// public key during the given epoch.
	ValidatorId          []byte   `protobuf:"bytes,1,opt,name=validator_id,json=validatorId,proto3" json:"validator_id,omitempty"`
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}