eos

type ABI struct {
	Types   []ABIType    `json:"types,omitempty"`
	Structs []StructDef  `json:"structs,omitempty"`
	Actions []ActionDef  `json:"actions,omitempty"`
	Tables  []TableDef   `json:"tables,omitempty"`
	Clauses []ClausePair `json:"clauses,omitempty"`
}

type ABIType struct {
	NewTypeName string `json:"new_type_name"`
	Type        string `json:"type"`
}

type API struct {
	HttpClient              *http.Client
	BaseURL                 string
	ChainID                 []byte
	Signer                  Signer
	Debug                   bool
	Compress                CompressionType
	DefaultMaxKCPUUsage     uint32 // in kilo-cpu cycles
	DefaultMaxNetUsageWords uint32 // in 8-bytes words
	// contains filtered or unexported fields
}

type AccountName Name

type AccountResp struct {
	AccountName AccountName  `json:"account_name"`
	Permissions []Permission `json:"permissions"`
}

type Action struct {
	Account       AccountName       `json:"account"`
	Name          ActionName        `json:"name"`
	Authorization []PermissionLevel `json:"authorization,omitempty"`
	ActionData
}

type ActionData struct {
	HexData HexBytes    `json:"hex_data,omitempty"`
	Data    interface{} `json:"data,omitempty" eos:"-"`
	// contains filtered or unexported fields
}

type ActionDef struct {
	Name              ActionName `json:"name"`
	Type              string     `json:"type"`
	RicardianContract string     `json:"ricardian_contract"`
}

type ActionName Name

type ActionTrace struct {
	Receiver AccountName `json:"receiver"`
	// Action     Action       `json:"act"` // FIXME: how do we unpack that ? what's on the other side anyway?
	Console    string       `json:"console"`
	RegionID   uint16       `json:"region_id"`
	CycleIndex int          `json:"cycle_index"`
	DataAccess []DataAccess `json:"data_access"`
}

type Asset struct {
	Amount int64
	Symbol
}

type Authority struct {
	Threshold uint32                  `json:"threshold"`
	Keys      []KeyWeight             `json:"keys"`
	Accounts  []PermissionLevelWeight `json:"accounts"`
}

type BlockHeader struct {
	Previous         SHA256Bytes              `json:"previous"`
	Timestamp        BlockTimestamp           `json:"timestamp"`
	TransactionMRoot SHA256Bytes              `json:"transaction_mroot"`
	ActionMRoot      SHA256Bytes              `json:"action_mroot"`
	BlockMRoot       SHA256Bytes              `json:"block_mroot"`
	Producer         AccountName              `json:"producer"`
	ScheduleVersion  uint32                   `json:"schedule_version"`
	NewProducers     OptionalProducerSchedule `json:"new_producers"`
}

type BlockResp struct {
	Previous              string           `json:"previous"`                // : "0000007a9dde66f1666089891e316ac4cb0c47af427ae97f93f36a4f1159a194",
	Timestamp             JSONTime         `json:"timestamp"`               // : "2017-12-04T17:12:08",
	TransactionMerkleRoot string           `json:"transaction_merkle_root"` // : "0000000000000000000000000000000000000000000000000000000000000000",
	Producer              AccountName      `json:"producer"`                // : "initj",
	ProducerChanges       []ProducerChange `json:"producer_changes"`        // : [],
	ProducerSignature     string           `json:"producer_signature"`      // : "203dbf00b0968bfc47a8b749bbfdb91f8362b27c3e148a8a3c2e92f42ec55e9baa45d526412c8a2fc0dd35b484e4262e734bea49000c6f9c8dbac3d8861c1386c0",
	Cycles                []Cycle          `json:"cycles"`                  // : [],
	ID                    string           `json:"id"`                      // : "0000007b677719bdd76d729c3ac36bed5790d5548aadc26804489e5e179f4a5b",
	BlockNum              uint64           `json:"block_num"`               // : 123,
	RefBlockPrefix        uint64           `json:"ref_block_prefix"`        // : 2624744919
}

type BlockTimestamp struct {
	time.Time
}

type ClausePair struct {
	ID   string `json:"id"`
	Body string `json:"body"`
}

type Code struct {
	AccountName AccountName `json:"account_name"`
	CodeHash    string      `json:"code_hash"`
	WAST        string      `json:"wast"` // TODO: decode into Go ast, see https://github.com/go-interpreter/wagon
	ABI         ABI         `json:"abi"`
}

type CompressionType uint8

type Currency struct {
	Precision uint8
	Name      CurrencyName
}

type CurrencyBalanceResp struct {
	EOSBalance        Asset    `json:"eos_balance"`
	StakedBalance     Asset    `json:"staked_balance"`
	UnstakingBalance  Asset    `json:"unstaking_balance"`
	LastUnstakingTime JSONTime `json:"last_unstaking_time"`
}

type CurrencyName string

type Cycle struct {
}

type Cycles []ShardSummary

type DataAccess struct {
	Type     string      `json:"type"` // "write", "read"?
	Code     AccountName `json:"code"`
	Scope    AccountName `json:"scope"`
	Sequence int         `json:"sequence"`
}

type Decoder struct {
	// contains filtered or unexported fields
}

type DeferredTransaction struct {
	*Transaction

	SenderID   uint32      `json:"sender_id"`
	Sender     AccountName `json:"sender"`
	DelayUntil JSONTime    `json:"delay_until"`
}

type Encoder struct {
	Order binary.ByteOrder
	// contains filtered or unexported fields
}

type FieldDef struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type GetRequiredKeysResp struct {
	RequiredKeys []ecc.PublicKey `json:"required_keys"`
}

type GetTableRowsRequest struct {
	JSON       bool   `json:"json"`
	Scope      string `json:"scope"`
	Code       string `json:"code"`
	Table      string `json:"table"`
	TableKey   string `json:"table_key"`
	LowerBound string `json:"lower_bound"`
	UpperBound string `json:"upper_bount"`
	Limit      uint32 `json:"limit,omitempty"` // defaults to 10 => chain_plugin.hpp:struct get_table_rows_params
}

type GetTableRowsResp struct {
	More bool            `json:"more"`
	Rows json.RawMessage `json:"rows"` // defer loading, as it depends on `JSON` being true/false.
}

type GoAwayMessage struct {
	Reason GoAwayReason `json:"reason"`
	NodeID SHA256Bytes  `json:"node_id"`
}

type GoAwayReason uint8

type HandshakeMessage struct {
	// net_plugin/protocol.hpp handshake_message
	NetworkVersion           int16         `json:"network_version"`
	ChainID                  SHA256Bytes   `json:"chain_id"`
	NodeID                   SHA256Bytes   `json:"node_id"` // sha256
	Key                      ecc.PublicKey `json:"key"`     // can be empty, producer key, or peer key
	Time                     Tstamp        `json:"time"`    // time?!
	Token                    SHA256Bytes   `json:"token"`   // digest of time to prove we own the private `key`
	Signature                ecc.Signature `json:"sig"`     // can be empty if no key, signature of the digest above
	P2PAddress               string        `json:"p2p_address"`
	LastIrreversibleBlockNum uint32        `json:"last_irreversible_block_num"`
	LastIrreversibleBlockID  SHA256Bytes   `json:"last_irreversible_block_id"`
	HeadNum                  uint32        `json:"head_num"`
	HeadID                   SHA256Bytes   `json:"head_id"`
	OS                       string        `json:"os"`
	Agent                    string        `json:"agent"`
	Generation               int16         `json:"generation"`
}

type HexBytes []byte

type IDListMode uint8

type InfoResp struct {
	ServerVersion            string      `json:"server_version"`              // "2cc40a4e"
	HeadBlockNum             uint32      `json:"head_block_num"`              // 2465669,
	LastIrreversibleBlockNum uint32      `json:"last_irreversible_block_num"` // 2465655
	HeadBlockID              string      `json:"head_block_id"`               // "00259f856bfa142d1d60aff77e70f0c4f3eab30789e9539d2684f9f8758f1b88",
	HeadBlockTime            JSONTime    `json:"head_block_time"`             //  "2018-02-02T04:19:32"
	HeadBlockProducer        AccountName `json:"head_block_producer"`         // "inita"
}

type JSONTime struct {
	time.Time
}

type KeyBag struct {
	Keys []*ecc.PrivateKey
}

type KeyWeight struct {
	PublicKey ecc.PublicKey `json:"key"`
	Weight    uint16        `json:"weight"`
}

type M map[string]interface{}

type MessageReflectTypes struct {
	Name        string
	ReflectType reflect.Type
}

type MyStruct struct {
	Currency
	Balance uint64
}

type Name string

type NetConnectResp string

type NetConnectionsResp struct {
	Peer          string           `json:"peer"`
	Connecting    bool             `json:"connecting"`
	Syncing       bool             `json:"syncing"`
	LastHandshake HandshakeMessage `json:"last_handshake"`
}

type NetDisconnectResp string

type NetStatusResp struct {
}

type NewAccount struct {
	Creator  AccountName `json:"creator"`
	Name     AccountName `json:"name"`
	Owner    Authority   `json:"owner"`
	Active   Authority   `json:"active"`
	Recovery Authority   `json:"recovery"`
}

type NoticeMessage struct {
	KnownTrx    OrderedBlockIDs `json:"known_trx"`
	KnownBlocks OrderedBlockIDs `json:"known_blocks"`
}

type OptionalProducerSchedule struct {
	ProducerSchedule
}

type OrderedBlockIDs struct {
	Unknown [3]byte       `json:"-"` ///// wuuttzthat?
	Mode    IDListMode    `json:"mode"`
	Pending uint32        `json:"pending"`
	IDs     []SHA256Bytes `json:"ids"`
}

type OrderedTransactionIDs struct {
	Unknown [3]byte       `json:"-"` ///// WWUUuuuuuuuuuuuutzthat ?
	Mode    IDListMode    `json:"mode"`
	Pending uint32        `json:"pending"`
	IDs     []SHA256Bytes `json:"ids"`
}

type P2PMessage interface {
	GetType() P2PMessageType
}

type P2PMessageEnvelope struct {
	Length     uint32         `json:"length"`
	Type       P2PMessageType `json:"type"`
	Payload    []byte         `json:"-"`
	P2PMessage P2PMessage     `json:"message" eos:"-"`
}

type P2PMessageType byte

type PackedTransaction struct {
	Signatures            []ecc.Signature `json:"signatures"`
	Compression           CompressionType `json:"compression"` // in C++, it's an enum, not sure how it Binary-marshals..
	PackedContextFreeData HexBytes        `json:"packed_context_free_data"`
	PackedTransaction     HexBytes        `json:"packed_trx"`
}

type PackedTransactionMessage struct {
	PackedTransaction
}

type Permission struct {
	PermName     string    `json:"perm_name"`
	Parent       string    `json:"parent"`
	RequiredAuth Authority `json:"required_auth"`
}

type PermissionLevel struct {
	Actor      AccountName    `json:"actor"`
	Permission PermissionName `json:"permission"`
}

type PermissionLevelWeight struct {
	Permission PermissionLevel `json:"permission"`
	Weight     uint16          `json:"weight"`
}

type PermissionName Name

type ProducerChange struct {
}

type ProducerKey struct {
	AccountName     AccountName   `json:"account_name"`
	BlockSigningKey ecc.PublicKey `json:"block_signing_key"`
}

type ProducerSchedule struct {
	Version   uint32        `json:"version"`
	Producers []ProducerKey `json:"producers"`
}

type PushTransactionFullResp struct {
	TransactionID string               `json:"transaction_id"`
	Processed     TransactionProcessed `json:"processed"` // WARN: is an `fc::variant` in server..
}

type PushTransactionShortResp struct {
	TransactionID string `json:"transaction_id"`
	Processed     bool   `json:"processed"` // WARN: is an `fc::variant` in server..
}

type RegionSummary struct {
	Region        uint16   `json:"region"`
	CyclesSummary []Cycles `json:"cycles_summary"`
}

type RequestMessage struct {
	ReqTrx    OrderedBlockIDs `json:"req_trx"`
	ReqBlocks OrderedBlockIDs `json:"req_blocks"`
}

type SHA256Bytes []byte // should always be 32 bytes

type ScopeName Name

type SequencedTransactionResp struct {
	SeqNum int `json:"seq_num"`
	TransactionResp
}

type SetABI struct {
	Account AccountName `json:"account"`
	ABI     ABI         `json:"abi"`
}

type SetCode struct {
	Account   AccountName `json:"account"`
	VMType    byte        `json:"vmtype"`
	VMVersion byte        `json:"vmversion"`
	Code      HexBytes    `json:"bytes"`
}

type ShardLock struct {
	AccountName AccountName `json:"account_name"`
	ScopeName   ScopeName   `json:"scope_name"`
}

type ShardSummary struct {
	ReadLocks    []ShardLock          `json:"read_locks"`
	WriteLocks   []ShardLock          `json:"write_locks"`
	Transactions []TransactionReceipt `json:"transactions"`
}

type SignedBlockHeader struct {
	BlockHeader
	ProducerSignature ecc.Signature `json:"producer_signature"`
}

type SignedBlockMessage struct {
	SignedBlockSummaryMessage
	InputTransactions []PackedTransaction `json:"input_transactions"`
}

type SignedBlockSummaryMessage struct {
	SignedBlockHeader
	Regions []RegionSummary `json:"regions"`
}

type SignedTransaction struct {
	*Transaction

	Signatures      []ecc.Signature `json:"signatures"`
	ContextFreeData []HexBytes      `json:"context_free_data"`
	// contains filtered or unexported fields
}

type SignedTransactionMessage struct {
	Signatures      []ecc.Signature `json:"signatures"`
	ContextFreeData []byte          `json:"context_free_data"`
}

type Signer interface {
	AvailableKeys() (out []ecc.PublicKey, err error)

	// Sign signs a `tx` transaction. It gets passed a
	// SignedTransaction because it is possible that it holds a few
	// signatures and requests this wallet only to add one or more
	// signatures it requires.
	Sign(tx *SignedTransaction, chainID []byte, requiredKeys ...ecc.PublicKey) (*SignedTransaction, error)

	ImportPrivateKey(wifPrivKey string) error
}

type StructDef struct {
	Name   string     `json:"name"`
	Base   string     `json:"base"`
	Fields []FieldDef `json:"fields,omitempty"`
}

type Symbol struct {
	Precision uint8
	Symbol    string
}

type SyncRequestMessage struct {
	StartBlock uint32 `json:"start_block"`
	EndBlock   uint32 `json:"end_block"`
}

type TableDef struct {
	Name      TableName `json:"name"`
	IndexType string    `json:"index_type"`
	KeyNames  []string  `json:"key_names,omitempty"`
	KeyTypes  []string  `json:"key_types,omitempty"`
	Type      string    `json:"type"`
}

type TableName Name

type TimeMessage struct {
	Origin      Tstamp `json:"org"`
	Receive     Tstamp `json:"rec"`
	Transmit    Tstamp `json:"xmt"`
	Destination Tstamp `json:"dst"`
}

type Transaction struct {
	Expiration     JSONTime `json:"expiration"`
	Region         uint16   `json:"region"`
	RefBlockNum    uint16   `json:"ref_block_num"`
	RefBlockPrefix uint32   `json:"ref_block_prefix"`

	MaxNetUsageWords Varuint32 `json:"max_net_usage_words"`
	MaxKCPUUsage     Varuint32 `json:"max_kcpu_usage"`
	DelaySec         Varuint32 `json:"delay_sec"` // number of secs to delay, making it cancellable for that duration

	ContextFreeActions []*Action `json:"context_free_actions,omitempty"`
	Actions            []*Action `json:"actions,omitempty"`
}

type TransactionProcessed struct {
	Status               string        `json:"status"`
	ID                   SHA256Bytes   `json:"id"`
	ActionTraces         []ActionTrace `json:"action_traces"`
	DeferredTransactions []string      `json:"deferred_transactions"` // that's not right... dig to find what's there..
}

type TransactionReceipt struct {
	Status        TransactionStatus `json:"status"`
	KCPUUsage     Varuint32         `json:"kcpu_usage"`
	NetUsageWords Varuint32         `json:"net_usage_words"`
	ID            SHA256Bytes       `json:"id"`
}

type TransactionResp struct {
	TransactionID string `json:"transaction_id"`
	Transaction   struct {
		Signatures            []ecc.Signature `json:"signatures"`
		Compression           CompressionType `json:"compression"`
		PackedContextFreeData HexBytes        `json:"packed_context_free_data"`
		ContextFreeData       []HexBytes      `json:"context_free_data"`
		PackedTransaction     HexBytes        `json:"packed_transaction"`
		Transaction           Transaction     `json:"transaction"`
	} `json:"transaction"`
}

type TransactionStatus uint8

type TransactionsResp struct {
	Transactions []SequencedTransactionResp
}

type Tstamp struct {
	time.Time
}

type TxOptions struct {
	MaxNetUsageWords uint32
	Delay            time.Duration
	MaxKCPUUsage     uint32 // If you want to override the CPU usage (in counts of 1024)
	//ExtraKCPUUsage uint32 // If you want to *add* some CPU usage to the estimated amount (in counts of 1024)
	Compress CompressionType
}

type Varuint32 uint32

type WalletSignTransactionResp struct {
	Signatures []ecc.Signature `json:"signatures"`
}

type WalletSigner struct {
	// contains filtered or unexported fields
}