Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ApplicationLog

type ApplicationLog struct {
	Container     util.Uint256
	IsTransaction bool
	Executions    []state.Execution
}

    ApplicationLog represent the results of the script executions for block or transaction.

    func NewApplicationLog

    func NewApplicationLog(hash util.Uint256, aers []state.AppExecResult, trig trigger.Type) ApplicationLog

      NewApplicationLog creates ApplicationLog from a set of several application execution results including only the results with the specified trigger.

      func (ApplicationLog) MarshalJSON

      func (l ApplicationLog) MarshalJSON() ([]byte, error)

        MarshalJSON implements implements json.Marshaler interface.

        func (*ApplicationLog) UnmarshalJSON

        func (l *ApplicationLog) UnmarshalJSON(data []byte) error

          UnmarshalJSON implements implements json.Unmarshaler interface.

          type Block

          type Block struct {
          	block.Block
          	BlockMetadata
          }

            Block wrapper used for the representation of block.Block / block.Base on the RPC Server.

            func NewBlock

            func NewBlock(b *block.Block, chain blockchainer.Blockchainer) Block

              NewBlock creates a new Block wrapper.

              func (Block) MarshalJSON

              func (b Block) MarshalJSON() ([]byte, error)

                MarshalJSON implements json.Marshaler interface.

                func (*Block) UnmarshalJSON

                func (b *Block) UnmarshalJSON(data []byte) error

                  UnmarshalJSON implements json.Unmarshaler interface.

                  type BlockMetadata

                  type BlockMetadata struct {
                  	Size          int           `json:"size"`
                  	NextBlockHash *util.Uint256 `json:"nextblockhash,omitempty"`
                  	Confirmations uint32        `json:"confirmations"`
                  }

                    BlockMetadata is an additional metadata added to standard block.Block.

                    type GetPeers

                    type GetPeers struct {
                    	Unconnected Peers `json:"unconnected"`
                    	Connected   Peers `json:"connected"`
                    	Bad         Peers `json:"bad"`
                    }

                      GetPeers payload for outputting peers in `getpeers` RPC call.

                      func NewGetPeers

                      func NewGetPeers() GetPeers

                        NewGetPeers creates a new GetPeers structure.

                        func (*GetPeers) AddBad

                        func (g *GetPeers) AddBad(addrs []string)

                          AddBad adds a set of peers to the bad peers slice.

                          func (*GetPeers) AddConnected

                          func (g *GetPeers) AddConnected(addrs []string)

                            AddConnected adds a set of peers to the connected peers slice.

                            func (*GetPeers) AddUnconnected

                            func (g *GetPeers) AddUnconnected(addrs []string)

                              AddUnconnected adds a set of peers to the unconnected peers slice.

                              type GetProof

                              type GetProof struct {
                              	Result  ProofWithKey `json:"proof"`
                              	Success bool         `json:"success"`
                              }

                                GetProof is a result of getproof RPC.

                                type Header struct {
                                	Hash          util.Uint256          `json:"hash"`
                                	Size          int                   `json:"size"`
                                	Version       uint32                `json:"version"`
                                	PrevBlockHash util.Uint256          `json:"previousblockhash"`
                                	MerkleRoot    util.Uint256          `json:"merkleroot"`
                                	Timestamp     uint64                `json:"time"`
                                	Index         uint32                `json:"index"`
                                	NextConsensus string                `json:"nextconsensus"`
                                	Witnesses     []transaction.Witness `json:"witnesses"`
                                	Confirmations uint32                `json:"confirmations"`
                                	NextBlockHash *util.Uint256         `json:"nextblockhash,omitempty"`
                                }

                                  Header wrapper used for the representation of block header on the RPC Server.

                                  func NewHeader

                                  func NewHeader(h *block.Header, chain blockchainer.Blockchainer) Header

                                    NewHeader creates a new Header wrapper.

                                    type Invoke

                                    type Invoke struct {
                                    	State          string
                                    	GasConsumed    int64
                                    	Script         []byte
                                    	Stack          []stackitem.Item
                                    	FaultException string
                                    	// Transaction represents transaction bytes. Use GetTransaction method to decode it.
                                    	Transaction []byte
                                    }

                                      Invoke represents code invocation result and is used by several RPC calls that invoke functions, scripts and generic bytecode. Transaction is represented in raw serialized format, use transaction.NewTransactionFromBytes or GetTransaction method to deserialize it.

                                      func (*Invoke) GetTransaction

                                      func (r *Invoke) GetTransaction(magic netmode.Magic) (*transaction.Transaction, error)

                                        GetTransaction returns decoded transaction from Invoke.Transaction bytes.

                                        func (Invoke) MarshalJSON

                                        func (r Invoke) MarshalJSON() ([]byte, error)

                                          MarshalJSON implements json.Marshaler.

                                          func (*Invoke) UnmarshalJSON

                                          func (r *Invoke) UnmarshalJSON(data []byte) error

                                            UnmarshalJSON implements json.Unmarshaler.

                                            type NEP17Balance

                                            type NEP17Balance struct {
                                            	Asset       util.Uint160 `json:"assethash"`
                                            	Amount      string       `json:"amount"`
                                            	LastUpdated uint32       `json:"lastupdatedblock"`
                                            }

                                              NEP17Balance represents balance for the single token contract.

                                              type NEP17Balances

                                              type NEP17Balances struct {
                                              	Balances []NEP17Balance `json:"balance"`
                                              	Address  string         `json:"address"`
                                              }

                                                NEP17Balances is a result for the getnep17balances RPC call.

                                                type NEP17Transfer

                                                type NEP17Transfer struct {
                                                	Timestamp   uint64       `json:"timestamp"`
                                                	Asset       util.Uint160 `json:"assethash"`
                                                	Address     string       `json:"transferaddress,omitempty"`
                                                	Amount      string       `json:"amount"`
                                                	Index       uint32       `json:"blockindex"`
                                                	NotifyIndex uint32       `json:"transfernotifyindex"`
                                                	TxHash      util.Uint256 `json:"txhash"`
                                                }

                                                  NEP17Transfer represents single NEP17 transfer event.

                                                  type NEP17Transfers

                                                  type NEP17Transfers struct {
                                                  	Sent     []NEP17Transfer `json:"sent"`
                                                  	Received []NEP17Transfer `json:"received"`
                                                  	Address  string          `json:"address"`
                                                  }

                                                    NEP17Transfers is a result for the getnep17transfers RPC.

                                                    type Peer

                                                    type Peer struct {
                                                    	Address string `json:"address"`
                                                    	Port    string `json:"port"`
                                                    }

                                                      Peer represents the peer.

                                                      type Peers

                                                      type Peers []Peer

                                                        Peers represent a slice of peers.

                                                        type ProofWithKey

                                                        type ProofWithKey struct {
                                                        	Key   []byte
                                                        	Proof [][]byte
                                                        }

                                                          ProofWithKey represens key-proof pair.

                                                          func (*ProofWithKey) DecodeBinary

                                                          func (p *ProofWithKey) DecodeBinary(r *io.BinReader)

                                                            DecodeBinary implements io.Serializable.

                                                            func (*ProofWithKey) EncodeBinary

                                                            func (p *ProofWithKey) EncodeBinary(w *io.BinWriter)

                                                              EncodeBinary implements io.Serializable.

                                                              func (*ProofWithKey) FromString

                                                              func (p *ProofWithKey) FromString(s string) error

                                                                FromString decodes p from hex-encoded string.

                                                                func (*ProofWithKey) MarshalJSON

                                                                func (p *ProofWithKey) MarshalJSON() ([]byte, error)

                                                                  MarshalJSON implements json.Marshaler.

                                                                  func (*ProofWithKey) String

                                                                  func (p *ProofWithKey) String() string

                                                                    String implements fmt.Stringer.

                                                                    func (*ProofWithKey) UnmarshalJSON

                                                                    func (p *ProofWithKey) UnmarshalJSON(data []byte) error

                                                                      UnmarshalJSON implements json.Unmarshaler.

                                                                      type RawMempool

                                                                      type RawMempool struct {
                                                                      	Height     uint32         `json:"height"`
                                                                      	Verified   []util.Uint256 `json:"verified"`
                                                                      	Unverified []util.Uint256 `json:"unverified"`
                                                                      }

                                                                        RawMempool represents a result of getrawmempool RPC call.

                                                                        type RelayResult

                                                                        type RelayResult struct {
                                                                        	Hash util.Uint256 `json:"hash"`
                                                                        }

                                                                          RelayResult ia a result of `sendrawtransaction` or `submitblock` RPC calls.

                                                                          type StateHeight

                                                                          type StateHeight struct {
                                                                          	BlockHeight uint32 `json:"blockHeight"`
                                                                          	StateHeight uint32 `json:"stateHeight"`
                                                                          }

                                                                            StateHeight is a result of getstateheight RPC.

                                                                            type TransactionMetadata

                                                                            type TransactionMetadata struct {
                                                                            	Blockhash     util.Uint256 `json:"blockhash,omitempty"`
                                                                            	Confirmations int          `json:"confirmations,omitempty"`
                                                                            	Timestamp     uint64       `json:"blocktime,omitempty"`
                                                                            	VMState       string       `json:"vmstate,omitempty"`
                                                                            }

                                                                              TransactionMetadata is an auxiliary struct for proper TransactionOutputRaw marshaling.

                                                                              type TransactionOutputRaw

                                                                              type TransactionOutputRaw struct {
                                                                              	transaction.Transaction
                                                                              	TransactionMetadata
                                                                              }

                                                                                TransactionOutputRaw is used as a wrapper to represents a Transaction.

                                                                                func NewTransactionOutputRaw

                                                                                func NewTransactionOutputRaw(tx *transaction.Transaction, header *block.Header, appExecResult *state.AppExecResult, chain blockchainer.Blockchainer) TransactionOutputRaw

                                                                                  NewTransactionOutputRaw returns a new ransactionOutputRaw object.

                                                                                  func (TransactionOutputRaw) MarshalJSON

                                                                                  func (t TransactionOutputRaw) MarshalJSON() ([]byte, error)

                                                                                    MarshalJSON implements json.Marshaler interface.

                                                                                    func (*TransactionOutputRaw) UnmarshalJSON

                                                                                    func (t *TransactionOutputRaw) UnmarshalJSON(data []byte) error

                                                                                      UnmarshalJSON implements json.Marshaler interface.

                                                                                      type UnclaimedGas

                                                                                      type UnclaimedGas struct {
                                                                                      	Address   util.Uint160
                                                                                      	Unclaimed big.Int
                                                                                      }

                                                                                        UnclaimedGas response wrapper

                                                                                        func (UnclaimedGas) MarshalJSON

                                                                                        func (g UnclaimedGas) MarshalJSON() ([]byte, error)

                                                                                          MarshalJSON implements json.Marshaler interface.

                                                                                          func (*UnclaimedGas) UnmarshalJSON

                                                                                          func (g *UnclaimedGas) UnmarshalJSON(data []byte) error

                                                                                            UnmarshalJSON implements json.Unmarshaler interface.

                                                                                            type ValidateAddress

                                                                                            type ValidateAddress struct {
                                                                                            	Address interface{} `json:"address"`
                                                                                            	IsValid bool        `json:"isvalid"`
                                                                                            }

                                                                                              ValidateAddress represents result of the `validateaddress` call. Notice that Address is an interface{} here because server echoes back whatever address value user has sent to it, even if it's not a string.

                                                                                              type Validator

                                                                                              type Validator struct {
                                                                                              	PublicKey keys.PublicKey `json:"publickey"`
                                                                                              	Votes     int64          `json:"votes,string"`
                                                                                              	Active    bool           `json:"active"`
                                                                                              }

                                                                                                Validator used for the representation of state.Validator on the RPC Server.

                                                                                                type VerifyProof

                                                                                                type VerifyProof struct {
                                                                                                	Value []byte
                                                                                                }

                                                                                                  VerifyProof is a result of verifyproof RPC. nil Value is considered invalid.

                                                                                                  func (*VerifyProof) MarshalJSON

                                                                                                  func (p *VerifyProof) MarshalJSON() ([]byte, error)

                                                                                                    MarshalJSON implements json.Marshaler.

                                                                                                    func (*VerifyProof) UnmarshalJSON

                                                                                                    func (p *VerifyProof) UnmarshalJSON(data []byte) error

                                                                                                      UnmarshalJSON implements json.Unmarshaler.

                                                                                                      type Version

                                                                                                      type Version struct {
                                                                                                      	Magic     netmode.Magic `json:"magic"`
                                                                                                      	TCPPort   uint16        `json:"tcpport"`
                                                                                                      	WSPort    uint16        `json:"wsport,omitempty"`
                                                                                                      	Nonce     uint32        `json:"nonce"`
                                                                                                      	UserAgent string        `json:"useragent"`
                                                                                                      	// StateRootInHeader is true if state root is contained in block header.
                                                                                                      	StateRootInHeader bool `json:"staterootinheader,omitempty"`
                                                                                                      }

                                                                                                        Version model used for reporting server version info.