types

type AccountBalanceRequest struct {
	NetworkIdentifier *NetworkIdentifier      `json:"network_identifier"`
	AccountIdentifier *AccountIdentifier      `json:"account_identifier"`
	BlockIdentifier   *PartialBlockIdentifier `json:"block_identifier,omitempty"`
}

type AccountBalanceResponse struct {
	BlockIdentifier *BlockIdentifier `json:"block_identifier"`
	// A single account may have a balance in multiple currencies.
	Balances []*Amount `json:"balances"`
	// Account-based blockchains that utilize a nonce or sequence number should include that number
	// in the metadata. This number could be unique to the identifier or global across the account
	// address.
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type AccountIdentifier struct {
	// The address may be a cryptographic public key (or some encoding of it) or a provided
	// username.
	Address    string                `json:"address"`
	SubAccount *SubAccountIdentifier `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]interface{} `json:"metadata,omitempty"`
}

type Allow struct {
	// All Operation.Status this implementation supports. Any status that is returned during parsing
	// that is not listed here will cause client validation to error.
	OperationStatuses []*OperationStatus `json:"operation_statuses"`
	// All Operation.Type this implementation supports. Any type that is returned during parsing
	// that is not listed here will cause client validation to error.
	OperationTypes []string `json:"operation_types"`
	// All Errors that this implementation could return. Any error that is returned during parsing
	// that is not listed here will cause client validation to error.
	Errors []*Error `json:"errors"`
}

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                 `json:"value"`
	Currency *Currency              `json:"currency"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type Block struct {
	BlockIdentifier       *BlockIdentifier `json:"block_identifier"`
	ParentBlockIdentifier *BlockIdentifier `json:"parent_block_identifier"`
	// The timestamp of the block in milliseconds since the Unix Epoch. The timestamp is stored in
	// milliseconds because some blockchains produce blocks more often than once a second.
	Timestamp    int64                  `json:"timestamp"`
	Transactions []*Transaction         `json:"transactions"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
}

type BlockIdentifier struct {
	// This is also known as the block height.
	Index int64  `json:"index"`
	Hash  string `json:"hash"`
}

type BlockRequest struct {
	NetworkIdentifier *NetworkIdentifier      `json:"network_identifier"`
	BlockIdentifier   *PartialBlockIdentifier `json:"block_identifier"`
}

type BlockResponse struct {
	Block *Block `json:"block"`
	// Some blockchains may require additional transactions to be fetched that weren't returned in
	// the block response (ex: block only returns transaction hashes). For blockchains with a lot of
	// transactions in each block, this can be very useful as consumers can concurrently fetch all
	// transactions returned.
	OtherTransactions []*TransactionIdentifier `json:"other_transactions,omitempty"`
}

type BlockTransactionRequest struct {
	NetworkIdentifier     *NetworkIdentifier     `json:"network_identifier"`
	BlockIdentifier       *BlockIdentifier       `json:"block_identifier"`
	TransactionIdentifier *TransactionIdentifier `json:"transaction_identifier"`
}

type BlockTransactionResponse struct {
	Transaction *Transaction `json:"transaction"`
}

type ConstructionMetadataRequest struct {
	NetworkIdentifier *NetworkIdentifier `json:"network_identifier"`
	// Some blockchains require different metadata for different types of transaction construction
	// (ex: delegation versus a transfer). Instead of requiring a blockchain node to return all
	// possible types of metadata for construction (which may require multiple node fetches), the
	// client can populate an options object to limit the metadata returned to only the subset
	// required.
	Options map[string]interface{} `json:"options"`
}

type ConstructionMetadataResponse struct {
	Metadata map[string]interface{} `json:"metadata"`
}

type ConstructionSubmitRequest struct {
	NetworkIdentifier *NetworkIdentifier `json:"network_identifier"`
	SignedTransaction string             `json:"signed_transaction"`
}

type ConstructionSubmitResponse struct {
	TransactionIdentifier *TransactionIdentifier `json:"transaction_identifier"`
	Metadata              map[string]interface{} `json:"metadata,omitempty"`
}

type Currency struct {
	// Canonical symbol associated with a currency.
	Symbol string `json:"symbol"`
	// 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 `json:"decimals"`
	// 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]interface{} `json:"metadata,omitempty"`
}

type Error struct {
	// Code is a network-specific error code. If desired, this code can be equivalent to an HTTP
	// status code.
	Code int32 `json:"code"`
	// Message is a network-specific error message.
	Message string `json:"message"`
	// An error is retriable if the same request may succeed if submitted again.
	Retriable bool `json:"retriable"`
}

type MempoolRequest struct {
	NetworkIdentifier *NetworkIdentifier `json:"network_identifier"`
}

type MempoolResponse struct {
	TransactionIdentifiers []*TransactionIdentifier `json:"transaction_identifiers"`
}

type MempoolTransactionRequest struct {
	NetworkIdentifier     *NetworkIdentifier     `json:"network_identifier"`
	TransactionIdentifier *TransactionIdentifier `json:"transaction_identifier"`
}

type MempoolTransactionResponse struct {
	Transaction *Transaction           `json:"transaction"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type MetadataRequest struct {
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type NetworkIdentifier struct {
	Blockchain string `json:"blockchain"`
	// 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                `json:"network"`
	SubNetworkIdentifier *SubNetworkIdentifier `json:"sub_network_identifier,omitempty"`
}

type NetworkListResponse struct {
	NetworkIdentifiers []*NetworkIdentifier `json:"network_identifiers"`
}

type NetworkOptionsResponse struct {
	Version *Version `json:"version"`
	Allow   *Allow   `json:"allow"`
}

type NetworkRequest struct {
	NetworkIdentifier *NetworkIdentifier     `json:"network_identifier"`
	Metadata          map[string]interface{} `json:"metadata,omitempty"`
}

type NetworkStatusResponse struct {
	CurrentBlockIdentifier *BlockIdentifier `json:"current_block_identifier"`
	// The timestamp of the block in milliseconds since the Unix Epoch. The timestamp is stored in
	// milliseconds because some blockchains produce blocks more often than once a second.
	CurrentBlockTimestamp  int64            `json:"current_block_timestamp"`
	GenesisBlockIdentifier *BlockIdentifier `json:"genesis_block_identifier"`
	Peers                  []*Peer          `json:"peers"`
}

type Operation struct {
	OperationIdentifier *OperationIdentifier `json:"operation_identifier"`
	// Restrict referenced related_operations to identifier indexes < 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 `json:"related_operations,omitempty"`
	// The network-specific type of the operation. Ensure that any type that can be returned here is
	// also specified in the NetowrkStatus. This can be very useful to downstream consumers that
	// parse all block data.
	Type string `json:"type"`
	// 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.
	// Blockchains with atomic transactions (all operations succeed or all operations fail) will
	// have the same status for each operation.
	Status   string                 `json:"status"`
	Account  *AccountIdentifier     `json:"account,omitempty"`
	Amount   *Amount                `json:"amount,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type OperationIdentifier struct {
	// The operation index is used to ensure each operation has a unique identifier within a
	// transaction.  To clarify, there may not be any notion of an operation index in the blockchain
	// being described.
	Index int64 `json:"index"`
	// 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).
	NetworkIndex *int64 `json:"network_index,omitempty"`
}

type OperationStatus struct {
	// The status is the network-specific status of the operation.
	Status string `json:"status"`
	// An Operation is considered successful if the Operation.Amount should affect the
	// Operation.Account. Some blockchains (like Bitcoin) only include successful operations in
	// blocks but other blockchains (like Ethereum) include unsuccessful operations that incur a
	// fee.  To reconcile the computed balance from the stream of Operations, it is critical to
	// understand which Operation.Status indicate an Operation is successful and should affect an
	// Account.
	Successful bool `json:"successful"`
}

type PartialBlockIdentifier struct {
	Index *int64  `json:"index,omitempty"`
	Hash  *string `json:"hash,omitempty"`
}

type Peer struct {
	PeerID   string                 `json:"peer_id"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type SubAccountIdentifier struct {
	// The SubAccount address may be a cryptographic value or some other identifier (ex: bonded)
	// that uniquely specifies a SubAccount.
	Address string `json:"address"`
	// 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]interface{} `json:"metadata,omitempty"`
}

type SubNetworkIdentifier struct {
	Network  string                 `json:"network"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type Transaction struct {
	TransactionIdentifier *TransactionIdentifier `json:"transaction_identifier"`
	Operations            []*Operation           `json:"operations"`
	// Transactions that are related to other transactions (like a cross-shard transactioin) should
	// include the tranaction_identifier of these transactions in the metadata.
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type TransactionIdentifier struct {
	// 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 `json:"hash"`
}

type Version struct {
	// The rosetta_version is the version of the Rosetta interface the implementation adheres to.
	// This can be useful for clients looking to reliably parse responses.
	RosettaVersion string `json:"rosetta_version"`
	// The node_version is the canonical version of the node runtime. This can help clients manage
	// deployments.
	NodeVersion string `json:"node_version"`
	// When a middleware server is used to adhere to the Rosetta interface, it should return its
	// version here. This can help clients manage deployments.
	MiddlewareVersion *string `json:"middleware_version,omitempty"`
	// Any other information that may be useful about versioning of dependent services should be
	// returned here.
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}