types

type AccountIdentifier struct {

	// The address may be a cryptographic public key (or some encoding of it) or a provided
	// username.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// The sub account identifier
	SubAccount *SubAccountIdentifier `protobuf:"bytes,2,opt,name=sub_account,json=subAccount,proto3" json:"sub_account,omitempty"`
	// Blockchains that utilize a username model (where the address is not a derivative of a
	// cryptographic public key) should specify the public key(s) owned by the address in metadata.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Amount struct {

	// Value of the transaction in atomic units represented as an arbitrary-sized signed integer.
	// For example, 1 BTC would be represented by a value of 100000000.
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// Currency is composed of a canonical Symbol and Decimals. This Decimals value is used to
	// convert an Amount.Value from atomic units (Satoshis) to standard units (Bitcoins).
	Currency *Currency `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"`
	// The metadata is protocol specific metadata
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Block struct {

	// BlockIdentifier uniquely identifies a block in a particular network.
	BlockIdentifier *BlockIdentifier `protobuf:"bytes,2,opt,name=block_identifier,json=blockIdentifier,proto3" json:"block_identifier,omitempty"`
	// BlockIdentifier uniquely identifies a block in a particular network.
	ParentBlockIdentifier *BlockIdentifier `` /* 126-byte string literal not displayed */
	// The timestamp of the block since the Unix Epoch. The rosetta spec only
	// support timestamp in milliseconds granularity.
	// (-- api-linter: core::0142::time-field-names=disabled
	//
	//	go/aip/not-precedent: This field was called timestamp in rosetta spec. --)
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Transactions within the block.
	Transactions []*Transaction `protobuf:"bytes,5,rep,name=transactions,proto3" json:"transactions,omitempty"`
	// Metadata for the block.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BlockIdentifier struct {

	// The block height.  Note that this this should be >= 0
	Index int64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// The block hash.
	Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	// contains filtered or unexported fields
}

type CoinChange struct {

	// CoinIdentifier uniquely identifies a Coin.
	CoinIdentifier *CoinIdentifier `protobuf:"bytes,1,opt,name=coin_identifier,json=coinIdentifier,proto3" json:"coin_identifier,omitempty"`
	// CoinActions are different state changes that a Coin can undergo
	CoinAction CoinChange_CoinAction `` /* 149-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CoinChange_CoinAction int32

type CoinIdentifier struct {

	// Identifier should be populated with a globally unique identifier of a Coin. In Bitcoin, this
	// identifier would be transaction_hash:index.
	Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	// contains filtered or unexported fields
}

type Currency struct {

	// Canonical symbol associated with a currency.
	Symbol string `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// Number of decimal places in the standard unit representation of the amount. For example, BTC
	// has 8 decimals. Note that it is not possible to represent the value of some currency in atomic
	// units that is not base 10.
	Decimals int32 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"`
	// Any additional information related to the currency itself. For example, it would be useful to
	// populate this object with the contract address of an ERC-20 token.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type NetworkIdentifier struct {

	// Blockchain the network is associated with
	Blockchain string `protobuf:"bytes,1,opt,name=blockchain,proto3" json:"blockchain,omitempty"`
	// If a blockchain has a specific chain-id or network identifier, it should go in
	// this field. It is up to the client to determine which network-specific identifier
	// is mainnet or testnet.
	Network string `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
	// In blockchains with sharded state, the SubNetworkIdentifier is required to query
	// some object on a specific shard. This identifier is optional for all non-sharded
	// blockchains.
	SubNetworkIdentifier *SubNetworkIdentifier `protobuf:"bytes,3,opt,name=sub_network_identifier,json=subNetworkIdentifier,proto3" json:"sub_network_identifier,omitempty"`
	// contains filtered or unexported fields
}

type Operation struct {

	// The operation_identifier uniquely identifies an operation within a transaction.
	OperationIdentifier *OperationIdentifier `protobuf:"bytes,1,opt,name=operation_identifier,json=operationIdentifier,proto3" json:"operation_identifier,omitempty"`
	// Restrict referenced related_operations to identifier indices " the current
	// operation_identifier.index. This ensures there exists a clear DAG-structure of relations.
	// Since operations are one-sided, one could imagine relating operations in a single transfer
	// or linking operations in a call tree.
	RelatedOperations []*OperationIdentifier `protobuf:"bytes,2,rep,name=related_operations,json=relatedOperations,proto3" json:"related_operations,omitempty"`
	// Type is the network-specific type of the operation. Ensure that any type that can be returned
	// here is also specified in the NetworkOptionsResponse. This can be very useful to downstream
	// consumers that parse all block data.
	Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	// Status is the network-specific status of the operation. Status is not defined on the transaction
	// object because blockchains with smart contracts may have transactions that partially apply (some
	// operations are successful and some are not). Blockchains with atomic transactions (all operations
	// succeed or all operations fail) will have the same status for each operation. On-chain operations
	// (operations retrieved in the /block and /block/transaction endpoints) MUST have a populated status
	// field (anything on-chain must have succeeded or failed). However, operations provided during
	// transaction construction (often times called "intent" in the documentation) MUST NOT have a
	// populated status field (operations yet to be included on-chain have not yet succeeded or failed).
	Status string `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	// The account_identifier uniquely identifies an account within a network. All fields in the
	// account_identifier are utilized to determine this uniqueness (including the metadata field,
	// if populated).
	Account *AccountIdentifier `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	// Amount is some Value of a Currency. It is considered invalid to specify a Value without a Currency.
	Amount *Amount `protobuf:"bytes,6,opt,name=amount,proto3" json:"amount,omitempty"`
	// CoinChange is used to represent a change in state of a some coin identified by a coin_identifier.
	// This object is part of the Operation model and must be populated for UTXO-based blockchains.
	// Coincidentally, this abstraction of UTXOs allows for supporting both account-based transfers and
	// UTXO-based transfers on the same blockchain (when a transfer is account-based, don't populate
	// this model).
	CoinChange *CoinChange `protobuf:"bytes,7,opt,name=coin_change,json=coinChange,proto3" json:"coin_change,omitempty"`
	// Metadata stores any protocol specific information regarding the operation
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type OperationIdentifier struct {

	// The operation index is used to ensure each operation has a unique identifier within a transaction.
	// This index is only relative to the transaction and NOT GLOBAL. The operations in each transaction
	// should start from index 0. To clarify, there may not be any notion of an operation index in the
	// blockchain being described.
	Index int64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// Some blockchains specify an operation index that is essential for client use. For example, Bitcoin
	// uses a network_index to identify which UTXO was used in a transaction. network_index should not be
	// populated if there is no notion of an operation index in a blockchain (typically most
	// account-based blockchains).
	// Note that this this should be >= 0
	NetworkIndex int64 `protobuf:"varint,2,opt,name=network_index,json=networkIndex,proto3" json:"network_index,omitempty"`
	// contains filtered or unexported fields
}

type RelatedTransaction struct {

	// The network_identifier specifies which network a particular object is associated with.
	// An unpopulated network identifier indicates that the related transaction is on the same network.
	NetworkIdentifier *NetworkIdentifier `protobuf:"bytes,1,opt,name=network_identifier,json=networkIdentifier,proto3" json:"network_identifier,omitempty"`
	// The transaction_identifier uniquely identifies a transaction in a particular network and block
	// or in the mempool.
	TransactionIdentifier *TransactionIdentifier `protobuf:"bytes,2,opt,name=transaction_identifier,json=transactionIdentifier,proto3" json:"transaction_identifier,omitempty"`
	// Used by RelatedTransaction to indicate the direction of the relation.
	// Can be used to indicate if a transaction relation is from child to parent or the reverse.
	Direction RelatedTransaction_Direction `` /* 136-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RelatedTransaction_Direction int32

type SubAccountIdentifier struct {

	// The SubAccount address may be a cryptographic value or some other identifier (ex: bonded) that uniquely
	// specifies a SubAccount.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// If the SubAccount address is not sufficient to uniquely specify a SubAccount, any other identifying
	// information can be stored here. It is important to note that two SubAccounts with identical addresses
	// but differing metadata will not be considered equal by clients.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type SubNetworkIdentifier struct {

	// The subnetwork identifier.
	Network string `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"`
	// Metadata info for the subnetwork.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Transaction struct {

	// The transaction_identifier uniquely identifies a transaction in a particular network and block
	// or in the mempool.
	TransactionIdentifier *TransactionIdentifier `protobuf:"bytes,1,opt,name=transaction_identifier,json=transactionIdentifier,proto3" json:"transaction_identifier,omitempty"`
	// The operations is an array of Operations that are associated with the transaction
	Operations []*Operation `protobuf:"bytes,2,rep,name=operations,proto3" json:"operations,omitempty"`
	// The related_transaction allows implementations to link together multiple transactions.
	// An unpopulated network identifier indicates that the related transaction is on the same network.
	RelatedTransactions []*RelatedTransaction `protobuf:"bytes,3,rep,name=related_transactions,json=relatedTransactions,proto3" json:"related_transactions,omitempty"`
	// Transactions that are related to other transactions (like a cross-shard transaction) should
	// include the tranaction_identifier of these transactions in the metadata.
	Metadata map[string]*anypb.Any `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type TransactionIdentifier struct {

	// The hash of the transaction.  Any transactions that are attributable only to a block (ex: a
	// block event) should use the hash of the block as the identifier.
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// contains filtered or unexported fields
}