metahash

type AbstractMethod struct {
	Jsonrpc string      `json:"jsonrpc"`
	Method  string      `json:"method"`
	Params  interface{} `json:"params,omitempty"`
}

type AddressDelegations struct {
	Address string `json:"address"`
	States  []struct {
		To    string `json:"to"`
		Value int64  `json:"value"`
		Tx    string `json:"tx"`
	} `json:"states"`
}

type Balance struct {
	Address           string `json:"address"`
	Received          int64  `json:"received"`
	Spent             int64  `json:"spent"`
	CountReceived     int64  `json:"count_received"`
	CountSpent        int64  `json:"count_spent"`
	CountTxs          int64  `json:"count_txs"`
	BlockNumber       int64  `json:"block_number"`
	CurrentBlock      int64  `json:"currentBlock"`
	Hash              string `json:"hash"`
	CountDelegatedOps int64  `json:"countDelegatedOps"`
	Delegate          int64  `json:"delegate"`
	Undelegate        int64  `json:"undelegate"`
	Delegated         int64  `json:"delegated"`
	Undelegated       int64  `json:"undelegated"`
	Reserved          int64  `json:"reserved"`
	CountForgedOps    int64  `json:"countForgedOps"`
	Forged            int64  `json:"forged"`
}

type BalanceArgs struct {
	Address string `json:"address"`
}

type BalancesArgs struct {
	Addresses []string `json:"addresses"`
}

type Block struct {
	Type       string `json:"type"`
	Hash       string `json:"hash"`
	PrevHash   string `json:"prev_hash"`
	TxHash     string `json:"tx_hash"`
	Number     int64  `json:"number"`
	TimeStamp  int64  `json:"timestamp"`
	CountTxs   int64  `json:"count_txs"`
	Sign       string `json:"sign"`
	Size       int64  `json:"size"`
	FileName   string `json:"fileName"`
	Signatures []struct {
		From        string `json:"from"`
		To          string `json:"to"`
		Value       int64  `json:"value"`
		Transaction string `json:"transaction"`
		Data        string `json:"data"`
		TimeStamp   int64  `json:"timestamp"`
		Type        string `json:"type"`
		BlockNumber int64  `json:"blockNumber"`
		Signature   string `json:"signature"`
		Publickey   string `json:"publickey"`
		Fee         int64  `json:"fee"`
		RealFee     int64  `json:"realFee"`
		Nonce       int64  `json:"nonce"`
		IntStatus   int64  `json:"intStatus"`
		Status      string `json:"status"`
	} `json:"signatures,omitempty"`
	Txs []*TransactionInfo `json:"txs"`
}

type BlockByHashArgs struct {
	Hash     string `json:"hash"`
	BeginTx  int64  `json:"beginTx,omitempty"`
	CountTxs int64  `json:"countTxs,omitempty"`
	Type     int8   `json:"type,omitempty"` // 0-4
}

type BlockByNumberArgs struct {
	Number   int64 `json:"number"`
	BeginTx  int64 `json:"beginTx,omitempty"`
	CountTxs int64 `json:"countTxs,omitempty"`
	Type     int8  `json:"type,omitempty"` // 0-4

}

type BlocksArgs struct {
	CountBlocks int64 `json:"countBlocks,omitempty"`
	BeginBlock  int64 `json:"beginBlock,omitempty"`
}

type CommonBalance struct {
	Balance int64 `json:"balance"`
}

type CountBlocks struct {
	CountBlocks int64 `json:"count_blocks"`
	BeginBlock  int64 `json:"beginBlock"`
}

type CountBlocksArgs struct {
}

type DumpBlock struct {
	Dump string `json:"dump"`
}

type DumpBlockByHashArgs struct {
	Hash  string `json:"hash"`
	IsHex bool   `json:"isHex,omitempty"`
}

type DumpBlockByNumberArgs struct {
	Number int64 `json:"number"`
	IsHex  bool  `json:"isHex,omitempty"`
}

type ForginSumArgs struct {
	BlockIndent int `json:"block_indent"`
}

type ForgingSum struct {
	Blocknumber int `json:"blockNumber"`
	Sums        []struct {
		Type  int   `json:"type"`
		Value int64 `json:"value"`
	} `json:"sums"`
}

type HTTPError struct {
	Code int
	// contains filtered or unexported fields
}

type HistoryArgs struct {
	Address  string        `json:"address"`
	BeginTx  int64         `json:"beginTx,omitempty"`
	CountTxs int64         `json:"countTxs,omitempty"`
	Filters  HistoryFilter `json:"filters,omitempty"`
}

type HistoryFilter struct {
	IsInput    bool `json:"isInput,omitempty"`    // isInput - Display only isInput transactions
	IsOutput   bool `json:"isOutput,omitempty"`   //isOutput - Display only isOutput transactions
	IsSuccess  bool `json:"isSuccess,omitempty"`  //isSuccess - Display only success transactions
	IsForging  bool `json:"isForging,omitempty"`  //isForging - Display only forging transactions
	IsTest     bool `json:"isTest,omitempty"`     //isTest - Display only test transactions
	IsDelegate bool `json:"isDelegate,omitempty"` //isDelegate - Display only delegation transactions
}

type LastNodeCount struct {
	Nodes []struct {
		Node  string `json:"node"`
		IP    string `json:"ip"`
		Type  string `json:"type"`
		Count int    `json:"count"`
	} `json:"nodes"`
	Day          int `json:"day"`
	Lastblockday int `json:"lastBlockDay"`
}

type LastTxsArgs struct {
}

type NodeArgs struct {
	Address    string `json:"address"`
	BeginTx    int64  `json:"beginTx,omitempty"`
	CountTxs   int64  `json:"countTxs,omitempty"`
	CountTests int    `json:"count_tests,omitempty"`
}

type NodeRaiting struct {
	Address      string `json:"address"`
	Raiting      int    `json:"raiting"`
	Day          int    `json:"day"`
	Lastblockday int    `json:"lastBlockDay"`
}

type NodeRegistration struct {
	Jsonrpc string `json:"jsonrpc"`
	Method  string `json:"method"`
	Params  struct {
		Host string `json:"host"`
		Name string `json:"name"`
		Type string `json:"type,omitempty"`
	} `json:"params"`
}

type NodeStats struct {
	Address            string `json:"address"`
	Type               string `json:"type"`
	AvgRps             string `json:"avgRps"`
	IsLatency          bool   `json:"isLatency"`
	IP                 string `json:"ip"`
	Geo                string `json:"geo"`
	State              string `json:"state"`
	Timestamp          int    `json:"timestamp"`
	Success            bool   `json:"success"`
	LastBlockTimestamp int    `json:"lastBlockTimestamp"`
}

type NodeStatsState struct {
	ID      string `json:"id"`
	Jsonrpc string `json:"jsonrpc"`
	Method  string `json:"method"`
	Params  struct {
		Type              string `json:"type"`
		Ver               string `json:"ver"`
		Address           string `json:"address"`
		Host              string `json:"host"`
		Blockheightcheck  string `json:"blockHeightCheck"`
		Requestsperminute string `json:"requestsPerMinute"`
		Latency           string `json:"latency"`
		Geo               string `json:"geo"`
		Success           string `json:"success"`
	} `json:"params"`
}

type NodeTest struct {
	TimeStamp int64  `json:"timestamp"`
	Method    string `json:"method"`
	Params    struct {
		Mhaddr   string `json:"mhaddr"`
		IP       string `json:"ip"`
		QPS      int64  `json:"qps"`
		Rps      int64  `json:"rps"`
		Closed   string `json:"closed"`
		Timeouts string `json:"timeouts"`
		Ver      string `json:"ver"`
		Success  string `json:"success"`
	} `json:"params"`
}

type NodeTrust struct {
	Address            string `json:"address"`
	Trust              int64  `json:"trust"`
	Data               string `json:"data"`
	Timestamp          int64  `json:"timestamp"`
	Lastblocktimestamp int64  `json:"lastBlockTimestamp"`
}

type NodeTrustData struct {
	State      int `json:"state"`
	Trust      int `json:"trust"`
	DelegateTo []struct {
		A string `json:"a"`
		V int64  `json:"v"`
	} `json:"delegate_to"`
	DelegatedFrom []struct {
		A string `json:"a"`
		V int64  `json:"v"`
	} `json:"delegated_from"`
}

type RPCClient interface {
	// Call is used to send a JSON-RPC request to the server endpoint.
	//
	// The spec states, that params can only be an array or an object, no primitive values.
	// So there are a few simple rules to notice:
	//
	// 1. no params: params field is omitted. e.g. Call("getinfo")
	//
	// 2. single params primitive value: value is wrapped in array. e.g. Call("getByID", 1423)
	//
	// 3. single params value array or object: value is unchanged. e.g. Call("storePerson", &Person{Name: "Alex"})
	//
	// 4. multiple params values: always wrapped in array. e.g. Call("setDetails", "Alex, 35, "Germany", true)
	//
	// Examples:
	//   Call("getinfo") -> {"method": "getinfo"}
	//   Call("getPersonId", 123) -> {"method": "getPersonId", "params": [123]}
	//   Call("setName", "Alex") -> {"method": "setName", "params": ["Alex"]}
	//   Call("setMale", true) -> {"method": "setMale", "params": [true]}
	//   Call("setNumbers", []int{1, 2, 3}) -> {"method": "setNumbers", "params": [1, 2, 3]}
	//   Call("setNumbers", 1, 2, 3) -> {"method": "setNumbers", "params": [1, 2, 3]}
	//   Call("savePerson", &Person{Name: "Alex", Age: 35}) -> {"method": "savePerson", "params": {"name": "Alex", "age": 35}}
	//   Call("setPersonDetails", "Alex", 35, "Germany") -> {"method": "setPersonDetails", "params": ["Alex", 35, "Germany"}}
	//
	// for more information, see the examples or the unit tests
	Call(method string, params ...interface{}) (*RPCResponse, error)
	CallWID(method string, params ...interface{}) (*RPCResponse, error)

	// CallRaw is like Call() but without magic in the requests.Params field.
	// The RPCRequest object is sent exactly as you provide it.
	// See docs: NewRequest, RPCRequest, Params()
	//
	// It is recommended to first consider Call() and CallFor()
	CallRaw(request *RPCRequest) (*RPCResponse, error)

	// CallFor is a very handy function to send a JSON-RPC request to the server endpoint
	// and directly specify an object to store the response.
	//
	// out: will store the unmarshaled object, if request was successful.
	// should always be provided by references. can be nil even on success.
	// the behaviour is the same as expected from json.Unmarshal()
	//
	// method and params: see Call() function
	//
	// if the request was not successful (network, http error) or the rpc response returns an error,
	// an error is returned. if it was an JSON-RPC error it can be casted
	// to *RPCError.
	//
	CallFor(out interface{}, method string, params ...interface{}) error

	// CallBatch invokes a list of RPCRequests in a single batch request.
	//
	// Most convenient is to use the following form:
	// CallBatch(RPCRequests{
	//   NewRequest("myMethod1", 1, 2, 3),
	//   NewRequest("myMethod2", "Test"),
	// })
	//
	// You can create the []*RPCRequest array yourself, but it is not recommended and you should notice the following:
	// - field Params is sent as provided, so Params: 2 forms an invalid json (correct would be Params: []int{2})
	// - you can use the helper function Params(1, 2, 3) to use the same format as in Call()
	// - field JSONRPC is overwritten and set to value: "2.0"
	// - field ID is overwritten and set incrementally and maps to the array position (e.g. requests[5].ID == 5)
	//
	//
	// Returns RPCResponses that is of type []*RPCResponse
	// - note that a list of RPCResponses can be received unordered so it can happen that: responses[i] != responses[i].ID
	// - RPCPersponses is enriched with helper functions e.g.: responses.HasError() returns  true if one of the responses holds an RPCError
	CallBatch(requests RPCRequests) (RPCResponses, error)

	// CallBatchRaw invokes a list of RPCRequests in a single batch request.
	// It sends the RPCRequests parameter is it passed (no magic, no id autoincrement).
	//
	// Consider to use CallBatch() instead except you have some good reason not to.
	//
	// CallBatchRaw(RPCRequests{
	//   &RPCRequest{
	//     ID: 123,            // this won't be replaced in CallBatchRaw
	//     JSONRPC: "wrong",   // this won't be replaced in CallBatchRaw
	//     Method: "myMethod1",
	//     Params: []int{1},   // there is no magic, be sure to only use array or object
	//   },
	//   &RPCRequest{
	//     ID: 612,
	//     JSONRPC: "2.0",
	//     Method: "myMethod2",
	//     Params: Params("Alex", 35, true), // you can use helper function Params() (see doc)
	//   },
	// })
	//
	// Returns RPCResponses that is of type []*RPCResponse
	// - note that a list of RPCResponses can be received unordered
	// - the id's must be mapped against the id's you provided
	// - RPCPersponses is enriched with helper functions e.g.: responses.HasError() returns  true if one of the responses holds an RPCError
	CallBatchRaw(requests RPCRequests) (RPCResponses, error)
}

type RPCClientOpts struct {
	HTTPClient    *http.Client
	CustomHeaders map[string]string
}

type RPCError struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
	// MetaHash hack
	CountBlocks int64 `json:"countBlocks"`
	KnownBlocks int64 `json:"knownBlocks,omitempty"`
	KnwonBlock  int64 `json:"knwonBlock,omitempty"` // да да
}

type RPCRequest struct {
	Method  string      `json:"method"`
	Params  interface{} `json:"params,omitempty"`
	ID      int         `json:"id,omitempty"`
	JSONRPC string      `json:"jsonrpc"`
}

type RPCRequests []*RPCRequest

type RPCResponse struct {
	JSONRPC string      `json:"jsonrpc"`
	Result  interface{} `json:"result,omitempty"`
	ID      int         `json:"id,int"`
	Error   *RPCError   `json:"error,omitempty"`

	// metahash
	Version string      `json:"version,omitempty"`
	Data    interface{} `json:"data,omitempty"`
}

type RPCResponses []*RPCResponse

type Status struct {
	ID      int    `json:"id"`
	Result  string `json:"result"`
	Version string `json:"version"`
	GitHash string `json:"git_hash"`
}

type TotalSupply struct {
	CirculatingSupply    string `json:"circulating_supply"`     //Number of coins in circulation
	CirculatingSupplyCmc string `json:"circulating_supply_cmc"` //Number of coins in circulation (by CoinMarketCap)
	TotalSupply          string `json:"total_supply"`           //Number of all coins emitted
	TotalSupplyDecimals  string `json:"total_supply_decimals"`  //Number of all coins emitted in micro units
	MaxSupply            string `json:"max_supply"`             //Maximum possible number of coins
	Decimals             int    `json:"decimals"`               //Number of decimal places
	Name                 string `json:"name"`                   //Name of the currency
}

type Transaction struct {
	Transaction TransactionInfo `json:"transaction"`
	CountBlocks int64           `json:"countBlocks"`
	KnownBlocks int64           `json:"knownBlocks"`
}

type TransactionArgs struct {
	Hash string `json:"hash"`
}

type TransactionInfo struct {
	From         string `json:"from" db:"fromA"`
	To           string `json:"to" db:"toA"`
	Value        int64  `json:"value"`
	Transaction  string `json:"transaction"`
	Data         string `json:"data"`
	TimeStamp    int64  `json:"timestamp" db:"timestamp,int64"`
	Type         string `json:"type" db:"typeTx"`
	BlockNumber  int64  `json:"blockNumber" db:"blockNumber"`
	Signature    string `json:"signature"`
	PublicKey    string `json:"publickey"`
	Fee          int64  `json:"fee"`
	RealFee      int64  `json:"realFee" db:"realFee"`
	Nonce        int64  `json:"nonce"`
	IntStatus    int64  `json:"intStatus" db:"intStatus"`
	Status       string `json:"status"`
	IsDelegate   bool   `json:"isDelegate,omitempty" db:"isDelegate"`
	DelegateInfo struct {
		IsDelegate   bool   `json:"isDelegate"`
		Delegate     int64  `json:"delegate,omitempty"`
		DelegateHash string `json:"delegateHash,omitempty"`
	} `json:"delegate_info,omitempty" db:"-"`
	Delegate     int64  `json:"delegate,omitempty"`
	DelegateHash string `json:"delegateHash,omitempty" db:"delegateHash"`
}