Back to godoc.org
github.com/aurawing/eos-go

Package eos

v0.9.1-0...-3b03c84
Latest Go to latest

The latest major version is .

Published: May 17, 2020 | License: MIT | Module: github.com/aurawing/eos-go

Index

Examples

Constants

const (
	GoAwayNoReason = GoAwayReason(iota)
	GoAwaySelfConnect
	GoAwayDuplicate
	GoAwayWrongChain
	GoAwayWrongVersion
	GoAwayForked
	GoAwayUnlinkable
	GoAwayBadTransaction
	GoAwayValidation
	GoAwayBenignOther
	GoAwayFatalOther
	GoAwayAuthentication
)

See plugins/net_plugin/include/eosio/net_plugin/protocol.hpp#L39

const (
	CompressionNone = CompressionType(iota)
	CompressionZlib
)
const (
	BlockSigningAuthorityV0Type = 0
)
const BlockTimestampFormat = "2006-01-02T15:04:05.999"
const JSONTimeFormat = "2006-01-02T15:04:05"
const OptionalField optionalFieldType = true

Variables

var EOSSymbol = Symbol{Precision: 4, Symbol: "EOS"}

EOSSymbol represents the standard EOS symbol on the chain. It's here just to speed up things.

var ErrNotFound = errors.New("resource not found")
var ErrUnknownMessageType = errors.New("unknown type")
var ErrVarIntBufferSize = errors.New("varint: invalid buffer size")
var REXSymbol = Symbol{Precision: 4, Symbol: "REX"}

REXSymbol represents the standard REX symbol on the chain. It's here just to speed up things.

var RegisteredActions = map[AccountName]map[ActionName]reflect.Type{}
var TypeSize = struct {
	Bool int
	Byte int

	Int8  int
	Int16 int

	Uint8   int
	Uint16  int
	Uint32  int
	Uint64  int
	Uint128 int

	Float32 int
	Float64 int

	Checksum160 int
	Checksum256 int
	Checksum512 int

	PublicKey int
	Signature int

	Tstamp         int
	BlockTimestamp int

	CurrencyName int

	// Deprecated: use Uint8 instead
	UInt8 int
	// Deprecated: use Uint16 instead
	UInt16 int
	// Deprecated: use Uint32 instead
	UInt32 int
	// Deprecated: use Uint64 instead
	UInt64 int
	// Deprecated: use Uint128 instead
	UInt128 int
}{
	Byte: 1,
	Bool: 1,

	Int8:  1,
	Int16: 2,

	Uint8:   1,
	Uint16:  2,
	Uint32:  4,
	Uint64:  8,
	Uint128: 16,

	Float32: 4,
	Float64: 8,

	Checksum160: 20,
	Checksum256: 32,
	Checksum512: 64,

	PublicKey: 34,
	Signature: 66,

	Tstamp:         8,
	BlockTimestamp: 4,

	CurrencyName: 7,
}

func BlockNum

func BlockNum(blockID string) uint32

BlockNum extracts the block number (or height) from a hex-encoded block ID.

func EnableABIDecoderLogging

func EnableABIDecoderLogging()

func EnableABIEncoderLogging

func EnableABIEncoderLogging()

func EnableCoreLogging

func EnableCoreLogging()

func EnableDecoderLogging

func EnableDecoderLogging()

func EnableEncoderLogging

func EnableEncoderLogging()

func ExtendedStringToName

func ExtendedStringToName(s string) (val uint64, err error)

ExtendedStringToName acts similar to StringToName with the big differences that it will automtically try to infer from which format to convert to a name. Current rules are: - If the `s` contains a `,` character, assumes it's a `Symbol` - If the `s` contains only upper-case characters and length is <= 7, assumes it's a `SymbolCode` - Otherwise, forwards `s` to `StringToName` directly

func MarshalBinary

func MarshalBinary(v interface{}) ([]byte, error)

func MustStringToName

func MustStringToName(s string) (val uint64)

func NameToString

func NameToString(in uint64) string

func NewLogger

func NewLogger(production bool) *zap.Logger

NewLogger a wrap to newLogger

func RegisterAction

func RegisterAction(accountName AccountName, actionName ActionName, obj interface{})

Registers Action objects..

func SigDigest

func SigDigest(chainID, payload, contextFreeData []byte) []byte

func StringToName

func StringToName(s string) (val uint64, err error)

func UnmarshalBinary

func UnmarshalBinary(data []byte, v interface{}) (err error)

func UnmarshalBinaryReader

func UnmarshalBinaryReader(reader io.Reader, v interface{}) (err error)

type ABI

type ABI struct {
	Version          string            `json:"version"`
	Types            []ABIType         `json:"types,omitempty"`
	Structs          []StructDef       `json:"structs,omitempty"`
	Actions          []ActionDef       `json:"actions,omitempty"`
	Tables           []TableDef        `json:"tables,omitempty"`
	RicardianClauses []ClausePair      `json:"ricardian_clauses,omitempty"`
	ErrorMessages    []ABIErrorMessage `json:"error_messages,omitempty"`
	Extensions       []*Extension      `json:"abi_extensions,omitempty"`
	Variants         []VariantDef      `json:"variants,omitempty" eos:"binary_extension"`
}

see: libraries/chain/contracts/abi_serializer.cpp:53... see: libraries/chain/include/eosio/chain/contracts/types.hpp:100

func NewABI

func NewABI(r io.Reader) (*ABI, error)

func (*ABI) ActionForName

func (a *ABI) ActionForName(name ActionName) *ActionDef

func (*ABI) DecodeAction

func (a *ABI) DecodeAction(data []byte, actionName ActionName) ([]byte, error)

func (*ABI) DecodeTableRow

func (a *ABI) DecodeTableRow(tableName TableName, data []byte) ([]byte, error)

func (*ABI) DecodeTableRowTyped

func (a *ABI) DecodeTableRowTyped(tableType string, data []byte) ([]byte, error)
Example

Code:

package main

import (
	"encoding/hex"
	"fmt"
	"strings"

	eos "github.com/aurawing/eos-go"
)

func main() {
	abi, err := eos.NewABI(strings.NewReader(abiJSON()))
	if err != nil {
		panic(fmt.Errorf("get ABI: %s", err))
	}

	tableDef := abi.TableForName(eos.TableName("votes"))
	if tableDef == nil {
		panic(fmt.Errorf("table be should be present"))
	}

	bytes, err := abi.DecodeTableRowTyped(tableDef.Type, data())
	if err != nil {
		panic(fmt.Errorf("decode row: %s", err))
	}

	fmt.Println(string(bytes))
}

func data() []byte {
	bytes, err := hex.DecodeString(`424e544441505000`)
	if err != nil {
		panic(fmt.Errorf("decode data: %s", err))
	}

	return bytes
}

func abiJSON() string {
	return `{
			"structs": [
				{
					"name": "vote_t",
					"fields": [
						{ "name": "symbl", "type": "symbol_code" }
					]
				}
			],
			"actions": [],
			"tables": [
				{
					"name": "votes",
					"type": "vote_t"
				}
			]
	}`
}

func (*ABI) EncodeAction

func (a *ABI) EncodeAction(actionName ActionName, json []byte) ([]byte, error)

func (*ABI) StructForName

func (a *ABI) StructForName(name string) *StructDef

func (*ABI) TableForName

func (a *ABI) TableForName(name TableName) *TableDef

func (*ABI) TypeNameForNewTypeName

func (a *ABI) TypeNameForNewTypeName(typeName string) (resolvedTypeName string, isAlias bool)

func (*ABI) VariantForName

func (a *ABI) VariantForName(name string) *VariantDef

type ABIBinToJSONResp

type ABIBinToJSONResp struct {
	Args M `json:"args"`
}

type ABIEncoder

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

type ABIErrorMessage

type ABIErrorMessage struct {
	Code    Uint64 `json:"error_code"`
	Message string `json:"error_msg"`
}

type ABIJSONToBinResp

type ABIJSONToBinResp struct {
	Binargs string `json:"binargs"`
}

type ABIType

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

type API

type API struct {
	HttpClient *http.Client
	BaseURL    string
	Signer     Signer
	Debug      bool
	Compress   CompressionType
	// Header is one or more headers to be added to all outgoing calls
	Header                  http.Header
	DefaultMaxCPUUsageMS    uint8
	DefaultMaxNetUsageWords uint32 // in 8-bytes words
	// contains filtered or unexported fields
}

func New

func New(baseURL string) *API

func (*API) ABIBinToJSON

func (api *API) ABIBinToJSON(code AccountName, action Name, payload HexBytes) (out M, err error)

func (*API) ABIJSONToBin

func (api *API) ABIJSONToBin(code AccountName, action Name, payload M) (out HexBytes, err error)

func (*API) CreateSnapshot

func (api *API) CreateSnapshot() (out *CreateSnapshotResp, err error)

CreateSnapshot will write a snapshot file on a nodeos with `producer_api` plugin loaded.

func (*API) EnableKeepAlives

func (api *API) EnableKeepAlives() bool

func (*API) FixKeepAlives

func (api *API) FixKeepAlives() bool

FixKeepAlives tests the remote server for keepalive support (the main `nodeos` software doesn't in the version from March 22nd 2018). Some endpoints front their node with a keep-alive supporting web server. Adjust the `KeepAlive` support of the client accordingly.

func (*API) GetABI

func (api *API) GetABI(account AccountName) (out *GetABIResp, err error)

func (*API) GetAccount

func (api *API) GetAccount(name AccountName) (out *AccountResp, err error)
Example

Code:

api := eos.New(getAPIURL())

account := eos.AccountName("eos.rex")
info, err := api.GetAccount(account)
if err != nil {
	if err == eos.ErrNotFound {
		fmt.Printf("unknown account: %s", account)
		return
	}

	panic(fmt.Errorf("get account: %s", err))
}

bytes, err := json.Marshal(info)
if err != nil {
	panic(fmt.Errorf("json marshal response: %s", err))
}

fmt.Println(string(bytes))

func (*API) GetActions

func (api *API) GetActions(params GetActionsRequest) (out *ActionsResp, err error)

func (*API) GetBlockByID

func (api *API) GetBlockByID(id string) (out *BlockResp, err error)

func (*API) GetBlockByNum

func (api *API) GetBlockByNum(num uint32) (out *BlockResp, err error)

func (*API) GetBlockByNumOrID

func (api *API) GetBlockByNumOrID(query string) (out *SignedBlock, err error)

func (*API) GetBlockByNumOrIDRaw

func (api *API) GetBlockByNumOrIDRaw(query string) (out interface{}, err error)

func (*API) GetCode

func (api *API) GetCode(account AccountName) (out *GetCodeResp, err error)

func (*API) GetCodeHash

func (api *API) GetCodeHash(account AccountName) (out Checksum256, err error)

func (*API) GetControlledAccounts

func (api *API) GetControlledAccounts(controllingAccount string) (out *ControlledAccountsResp, err error)

func (*API) GetCurrencyBalance

func (api *API) GetCurrencyBalance(account AccountName, symbol string, code AccountName) (out []Asset, err error)

func (*API) GetCurrencyStats

func (api *API) GetCurrencyStats(code AccountName, symbol string) (out *GetCurrencyStatsResp, err error)

func (*API) GetDBSize

func (api *API) GetDBSize() (out *DBSizeResp, err error)

func (*API) GetInfo

func (api *API) GetInfo() (out *InfoResp, err error)
Example

Code:

api := eos.New(getAPIURL())

info, err := api.GetInfo()
if err != nil {
	panic(fmt.Errorf("get info: %s", err))
}

bytes, err := json.Marshal(info)
if err != nil {
	panic(fmt.Errorf("json marshal response: %s", err))
}

fmt.Println(string(bytes))

func (*API) GetIntegrityHash

func (api *API) GetIntegrityHash() (out *GetIntegrityHashResp, err error)

GetIntegrityHash will produce a hash corresponding to current state. Requires `producer_api` and useful when loading from a snapshot

func (*API) GetKeyAccounts

func (api *API) GetKeyAccounts(publicKey string) (out *KeyAccountsResp, err error)

func (*API) GetNetConnections

func (api *API) GetNetConnections() (out []*NetConnectionsResp, err error)

func (*API) GetNetStatus

func (api *API) GetNetStatus(host string) (out *NetStatusResp, err error)

func (*API) GetProducers

func (api *API) GetProducers() (out *ProducersResp, err error)

func (*API) GetPublicKeys

func (api *API) GetPublicKeys() (out []*ecc.PublicKey, err error)

func (*API) GetRawABI

func (api *API) GetRawABI(params GetRawABIRequest) (out *GetRawABIResp, err error)

func (*API) GetRawCodeAndABI

func (api *API) GetRawCodeAndABI(account AccountName) (out *GetRawCodeAndABIResp, err error)

func (*API) GetRequiredKeys

func (api *API) GetRequiredKeys(tx *Transaction) (out *GetRequiredKeysResp, err error)

func (*API) GetScheduledTransactions

func (api *API) GetScheduledTransactions() (out *ScheduledTransactionsResp, err error)

GetScheduledTransactions returns the Top 100 scheduled transactions

func (*API) GetScheduledTransactionsWithBounds

func (api *API) GetScheduledTransactionsWithBounds(lower_bound string, limit uint32) (out *ScheduledTransactionsResp, err error)

GetScheduledTransactionsWithBounds returns scheduled transactions within specified bounds

func (*API) GetTableByScope

func (api *API) GetTableByScope(params GetTableByScopeRequest) (out *GetTableByScopeResp, err error)

func (*API) GetTableRows

func (api *API) GetTableRows(params GetTableRowsRequest) (out *GetTableRowsResp, err error)

func (*API) GetTransaction

func (api *API) GetTransaction(id string) (out *TransactionResp, err error)

func (*API) GetTransactionRaw

func (api *API) GetTransactionRaw(id string) (out json.RawMessage, err error)

func (*API) GetTransactions

func (api *API) GetTransactions(name AccountName) (out *TransactionsResp, err error)

func (*API) IsProducerPaused

func (api *API) IsProducerPaused() (out bool, err error)

IsProducerPaused queries the blockchain for the pause statement of block production.

func (*API) ListKeys

func (api *API) ListKeys(walletNames ...string) (out []*ecc.PrivateKey, err error)

func (*API) ListWallets

func (api *API) ListWallets(walletName ...string) (out []string, err error)

func (*API) NetConnect

func (api *API) NetConnect(host string) (out NetConnectResp, err error)

func (*API) NetDisconnect

func (api *API) NetDisconnect(host string) (out NetDisconnectResp, err error)

func (*API) ProducerPause

func (api *API) ProducerPause() error

ProducerPause will pause block production on a nodeos with `producer_api` plugin loaded.

func (*API) ProducerResume

func (api *API) ProducerResume() error

ProducerResume will resume block production on a nodeos with `producer_api` plugin loaded. Obviously, this needs to be a producing node on the producers schedule for it to do anything.

func (*API) PushTransaction

func (api *API) PushTransaction(tx *PackedTransaction) (out *PushTransactionFullResp, err error)

PushTransaction submits a properly filled (tapos), packed and signed transaction to the blockchain.

Example (Transfer_EOS)

Code:

package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"os"

	eos "github.com/aurawing/eos-go"
	"github.com/aurawing/eos-go/token"
)

func main() {
	api := eos.New(getAPIURL())

	keyBag := &eos.KeyBag{}
	err := keyBag.ImportPrivateKey(readPrivateKey())
	if err != nil {
		panic(fmt.Errorf("import private key: %s", err))
	}
	api.SetSigner(keyBag)

	from := eos.AccountName("eosuser1")
	to := eos.AccountName("eosuser2")
	quantity, err := eos.NewEOSAssetFromString("1.0000 EOS")
	memo := ""

	if err != nil {
		panic(fmt.Errorf("invalid quantity: %s", err))
	}

	txOpts := &eos.TxOptions{}
	if err := txOpts.FillFromChain(api); err != nil {
		panic(fmt.Errorf("filling tx opts: %s", err))
	}

	tx := eos.NewTransaction([]*eos.Action{token.NewTransfer(from, to, quantity, memo)}, txOpts)
	signedTx, packedTx, err := api.SignTransaction(tx, txOpts.ChainID, eos.CompressionNone)
	if err != nil {
		panic(fmt.Errorf("sign transaction: %s", err))
	}

	content, err := json.MarshalIndent(signedTx, "", "  ")
	if err != nil {
		panic(fmt.Errorf("json marshalling transaction: %s", err))
	}

	fmt.Println(string(content))
	fmt.Println()

	response, err := api.PushTransaction(packedTx)
	if err != nil {
		panic(fmt.Errorf("push transaction: %s", err))
	}

	fmt.Printf("Transaction [%s] submitted to the network succesfully.\n", hex.EncodeToString(response.Processed.ID))
}

func readPrivateKey() string {
	// Right now, the key is read from an environment variable, it's an example after all.
	// In a real-world scenario, would you probably integrate with a real wallet or something similar
	envName := "EOS_GO_PRIVATE_KEY"
	privateKey := os.Getenv(envName)
	if privateKey == "" {
		panic(fmt.Errorf("private key environment variable %q must be set", envName))
	}

	return privateKey
}

func (*API) PushTransactionRaw

func (api *API) PushTransactionRaw(tx *PackedTransaction) (out json.RawMessage, err error)

func (*API) SetCustomGetRequiredKeys

func (api *API) SetCustomGetRequiredKeys(f func(tx *Transaction) ([]ecc.PublicKey, error))

func (*API) SetSigner

func (api *API) SetSigner(s Signer)

func (*API) SignPushActions

func (api *API) SignPushActions(a ...*Action) (out *PushTransactionFullResp, err error)

SignPushActions will create a transaction, fill it with default values, sign it and submit it to the chain. It is the highest level function on top of the `/v1/chain/push_transaction` endpoint.

func (*API) SignPushActionsWithOpts

func (api *API) SignPushActionsWithOpts(actions []*Action, opts *TxOptions) (out *PushTransactionFullResp, err error)

func (*API) SignPushTransaction

func (api *API) SignPushTransaction(tx *Transaction, chainID Checksum256, compression CompressionType) (out *PushTransactionFullResp, err error)

SignPushTransaction will sign a transaction and submit it to the chain.

func (*API) SignTransaction

func (api *API) SignTransaction(tx *Transaction, chainID Checksum256, compression CompressionType) (*SignedTransaction, *PackedTransaction, error)

SignTransaction will sign and pack a transaction, but not submit to the chain. It lives on the `api` object because it might query the blockchain to learn which keys are required to sign this particular transaction.

You can override the way we request keys (which defaults to `api.GetRequiredKeys()`) with SetCustomGetRequiredKeys().

To sign a transaction, you need a Signer defined on the `API` object. See SetSigner.

func (*API) WalletCreate

func (api *API) WalletCreate(walletName string) (err error)

func (*API) WalletImportKey

func (api *API) WalletImportKey(walletName, wifPrivKey string) (err error)

WalletImportKey loads a new WIF-encoded key into the wallet.

func (*API) WalletLock

func (api *API) WalletLock(walletName string) (err error)

func (*API) WalletLockAll

func (api *API) WalletLockAll() (err error)

func (*API) WalletOpen

func (api *API) WalletOpen(walletName string) (err error)

func (*API) WalletPublicKeys

func (api *API) WalletPublicKeys() (out []ecc.PublicKey, err error)

func (*API) WalletSetTimeout

func (api *API) WalletSetTimeout(timeout int32) (err error)

func (*API) WalletSignTransaction

func (api *API) WalletSignTransaction(tx *SignedTransaction, chainID []byte, pubKeys ...ecc.PublicKey) (out *WalletSignTransactionResp, err error)

func (*API) WalletUnlock

func (api *API) WalletUnlock(walletName, password string) (err error)

type APIError

type APIError struct {
	Code        int    `json:"code"` // http code
	Message     string `json:"message"`
	ErrorStruct struct {
		Code    int              `json:"code"` // https://docs.google.com/spreadsheets/d/1uHeNDLnCVygqYK-V01CFANuxUwgRkNkrmeLm9MLqu9c/edit#gid=0
		Name    string           `json:"name"`
		What    string           `json:"what"`
		Details []APIErrorDetail `json:"details"`
	} `json:"error"`
}

APIError represents the errors as reported by the server

func NewAPIError

func NewAPIError(httpCode int, msg string, e eoserr.Error) *APIError

func (APIError) Error

func (e APIError) Error() string

func (APIError) IsUnknownKeyError

func (e APIError) IsUnknownKeyError() bool

IsUnknowKeyError determines if the APIError is a 500 error with an `unknown key` message in at least one of the detail element. Some endpoint like `/v1/chain/get_account` returns a body in the form:

```

 {
 	"code": 500,
 	"message": "Internal Service Error",
 	"error": {
 		"code": 0,
 		"name": "exception",
 		"what": "unspecified",
 		"details": [
		 		{
		 			"message": "unknown key (<... redacted ...>): (0 eos.rex)",
		 			"file": "http_plugin.cpp",
		 			"line_number": 589,
		 			"method": "handle_exception"
		 		}
 		]
 	}
 }

```

This will check if root code is a 500, that inner error code is 0 and there is a detail message starting with prefix `"unknown key"`.

type APIErrorDetail

type APIErrorDetail struct {
	Message    string `json:"message"`
	File       string `json:"file"`
	LineNumber int    `json:"line_number"`
	Method     string `json:"method"`
}

type AccountName

type AccountName Name

func AN

func AN(in string) AccountName

type AccountRAMDelta

type AccountRAMDelta struct {
	Account AccountName `json:"account"`
	Delta   Int64       `json:"delta"`
}

type AccountResourceLimit

type AccountResourceLimit struct {
	Used      Int64 `json:"used"`
	Available Int64 `json:"available"`
	Max       Int64 `json:"max"`
}

type AccountResp

type AccountResp struct {
	AccountName            AccountName          `json:"account_name"`
	Privileged             bool                 `json:"privileged"`
	LastCodeUpdate         JSONTime             `json:"last_code_update"`
	Created                JSONTime             `json:"created"`
	CoreLiquidBalance      Asset                `json:"core_liquid_balance"`
	RAMQuota               Int64                `json:"ram_quota"`
	RAMUsage               Int64                `json:"ram_usage"`
	NetWeight              Int64                `json:"net_weight"`
	CPUWeight              Int64                `json:"cpu_weight"`
	NetLimit               AccountResourceLimit `json:"net_limit"`
	CPULimit               AccountResourceLimit `json:"cpu_limit"`
	Permissions            []Permission         `json:"permissions"`
	TotalResources         TotalResources       `json:"total_resources"`
	SelfDelegatedBandwidth DelegatedBandwidth   `json:"self_delegated_bandwidth"`
	RefundRequest          *RefundRequest       `json:"refund_request"`
	VoterInfo              VoterInfo            `json:"voter_info"`
}

type Action

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

Action

func (Action) Digest

func (a Action) Digest() Checksum256

func (*Action) MapToRegisteredAction

func (a *Action) MapToRegisteredAction() error

func (*Action) MarshalJSON

func (a *Action) MarshalJSON() ([]byte, error)

type ActionData

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

func NewActionData

func NewActionData(obj interface{}) ActionData

func NewActionDataFromHexData

func NewActionDataFromHexData(data []byte) ActionData

func (*ActionData) EncodeActionData

func (data *ActionData) EncodeActionData() ([]byte, error)

func (*ActionData) SetToServer

func (a *ActionData) SetToServer(toServer bool)

type ActionDef

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

type ActionName

type ActionName Name

func ActN

func ActN(in string) ActionName

type ActionResp

type ActionResp struct {
	GlobalSeq  JSONInt64      `json:"global_action_seq"`
	AccountSeq JSONInt64      `json:"account_action_seq"`
	BlockNum   uint32         `json:"block_num"`
	BlockTime  BlockTimestamp `json:"block_time"`
	Trace      ActionTrace    `json:"action_trace"`
}

type ActionTrace

type ActionTrace struct {
	Receipt                                *ActionTraceReceipt `json:"receipt,omitempty"`
	Receiver                               AccountName         `json:"receiver"`
	Action                                 *Action             `json:"act"`
	Elapsed                                Int64               `json:"elapsed"`
	Console                                string              `json:"console"`
	TransactionID                          Checksum256         `json:"trx_id"`
	InlineTraces                           []ActionTrace       `json:"inline_traces"`
	ContextFree                            bool                `json:"context_free"`
	BlockTime                              BlockTimestamp      `json:"block_time"`
	BlockNum                               uint32              `json:"block_num"`
	ProducerBlockID                        Checksum256         `json:"producer_block_id"`
	AccountRAMDeltas                       []*AccountRAMDelta  `json:"account_ram_deltas"`
	ErrorCode                              *Uint64             `json:"error_code"`
	Except                                 *Except             `json:"except"`
	ActionOrdinal                          uint32              `json:"action_ordinal"`
	CreatorActionOrdinal                   uint32              `json:"creator_action_ordinal"`
	ClosestUnnotifiedAncestorActionOrdinal uint32              `json:"closest_unnotified_ancestor_action_ordinal"`
}

type ActionTraceReceipt

type ActionTraceReceipt struct {
	Receiver        AccountName                    `json:"receiver"`
	ActionDigest    string                         `json:"act_digest"`
	GlobalSequence  Uint64                         `json:"global_sequence"`
	ReceiveSequence Uint64                         `json:"recv_sequence"`
	AuthSequence    []TransactionTraceAuthSequence `json:"auth_sequence"` // [["account", sequence], ["account", sequence]]
	CodeSequence    Uint64                         `json:"code_sequence"`
	ABISequence     Uint64                         `json:"abi_sequence"`
}

type ActionsResp

type ActionsResp struct {
	Actions               []ActionResp `json:"actions"`
	LastIrreversibleBlock uint32       `json:"last_irreversible_block"`
}

type Asset

type Asset struct {
	Amount Int64
	Symbol
}

NOTE: there's also ExtendedAsset which is a quantity with the attached contract (AccountName)

func NewAsset

func NewAsset(in string) (out Asset, err error)

NewAsset reads from a string an EOS asset.

Deprecated: Use `NewAssetFromString` instead

func NewAssetFromString

func NewAssetFromString(in string) (out Asset, err error)

NewAssetFromString reads a string an decode it to an eos.Asset structure if possible. The input must contains an amount and a symbol. The precision is inferred based on the actual number of decimals present.

func NewEOSAsset

func NewEOSAsset(amount int64) Asset

func NewEOSAssetFromString

func NewEOSAssetFromString(input string) (Asset, error)

func NewFixedSymbolAssetFromString

func NewFixedSymbolAssetFromString(symbol Symbol, input string) (out Asset, err error)

func NewREXAssetFromString

func NewREXAssetFromString(input string) (Asset, error)

func (Asset) Add

func (a Asset) Add(other Asset) Asset

func (Asset) MarshalJSON

func (a Asset) MarshalJSON() (data []byte, err error)

func (Asset) String

func (a Asset) String() string

func (Asset) Sub

func (a Asset) Sub(other Asset) Asset

func (*Asset) UnmarshalJSON

func (a *Asset) UnmarshalJSON(data []byte) error

type Authority

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

type BaseVariant

type BaseVariant struct {
	TypeID uint
	Impl   interface{}
}

func (*BaseVariant) Assign

func (a *BaseVariant) Assign(typeID uint, impl interface{})

func (*BaseVariant) DoFor

func (a *BaseVariant) DoFor(doers map[uint]OnVariant) error

func (*BaseVariant) MarshalJSON

func (a *BaseVariant) MarshalJSON() ([]byte, error)

func (*BaseVariant) Obtain

func (a *BaseVariant) Obtain() (typeID uint, impl interface{})

func (*BaseVariant) UnmarshalBinaryVariant

func (a *BaseVariant) UnmarshalBinaryVariant(decoder *Decoder, newImplPointer map[uint]VariantImplFactory) error

func (*BaseVariant) UnmarshalJSON

func (a *BaseVariant) UnmarshalJSON(data []byte, newImplPointer map[uint]VariantImplFactory) error

type Blob

type Blob string

Blob is base64 encoded data https://github.com/EOSIO/fc/blob/0e74738e938c2fe0f36c5238dbc549665ddaef82/include/fc/variant.hpp#L47

func (Blob) Data

func (b Blob) Data() ([]byte, error)

Data returns decoded base64 data

func (Blob) String

func (b Blob) String() string

String returns the blob as a string

type BlockHeader

type BlockHeader struct {
	Timestamp        BlockTimestamp `json:"timestamp"`
	Producer         AccountName    `json:"producer"`
	Confirmed        uint16         `json:"confirmed"`
	Previous         Checksum256    `json:"previous"`
	TransactionMRoot Checksum256    `json:"transaction_mroot"`
	ActionMRoot      Checksum256    `json:"action_mroot"`
	ScheduleVersion  uint32         `json:"schedule_version"`

	// EOSIO 1.x
	NewProducersV1 *ProducerSchedule `json:"new_producers,omitempty" eos:"optional"`

	HeaderExtensions []*Extension `json:"header_extensions"`
}

func (*BlockHeader) BlockID

func (b *BlockHeader) BlockID() (Checksum256, error)

func (*BlockHeader) BlockNumber

func (b *BlockHeader) BlockNumber() uint32

type BlockHeaderExtension

type BlockHeaderExtension interface {
	TypeID() BlockHeaderExtensionType
}

type BlockHeaderExtensionType

type BlockHeaderExtensionType uint16
const (
	EOS_ProtocolFeatureActivation BlockHeaderExtensionType = iota
	EOS_ProducerScheduleChangeExtension
)

type BlockResp

type BlockResp struct {
	SignedBlock
	ID             Checksum256 `json:"id"`
	BlockNum       uint32      `json:"block_num"`
	RefBlockPrefix uint32      `json:"ref_block_prefix"`
}

type BlockSigningAuthority

type BlockSigningAuthority struct {
	BaseVariant
}

See libraries/chain/include/eosio/chain/producer_schedule.hpp#L161

func (*BlockSigningAuthority) UnmarshalBinary

func (a *BlockSigningAuthority) UnmarshalBinary(decoder *Decoder) error

func (*BlockSigningAuthority) UnmarshalJSON

func (a *BlockSigningAuthority) UnmarshalJSON(data []byte) error

type BlockSigningAuthorityV0

type BlockSigningAuthorityV0 struct {
	Threshold uint32       `json:"threshold"`
	Keys      []*KeyWeight `json:"keys"`
}

See libraries/chain/include/eosio/chain/producer_schedule.hpp#L100

type BlockState

type BlockState struct {
	BlockNum                         uint32 `json:"block_num"`
	DPoSProposedIrreversibleBlockNum uint32 `json:"dpos_proposed_irreversible_blocknum"`
	DPoSIrreversibleBlockNum         uint32 `json:"dpos_irreversible_blocknum"`

	// Hybrid (dynamic types)
	ActiveSchedule *ProducerScheduleOrAuthoritySchedule `json:"active_schedule"`

	BlockrootMerkle          *MerkleRoot          `json:"blockroot_merkle,omitempty"`
	ProducerToLastProduced   [][2]EOSNameOrUint32 `json:"producer_to_last_produced,omitempty"`
	ProducerToLastImpliedIRB [][2]EOSNameOrUint32 `json:"producer_to_last_implied_irb,omitempty"`

	// EOSIO 1.x
	BlockSigningKeyV1 *ecc.PublicKey `json:"block_signing_key,omitempty"`

	// EOSIO 2.x
	ValidBlockSigningAuthorityV2 *BlockSigningAuthority `json:"valid_block_signing_authority,omitempty"`

	ConfirmCount []uint32 `json:"confirm_count,omitempty"`

	BlockID                   string                `json:"id"`
	PendingSchedule           *PendingSchedule      `json:"pending_schedule"`
	ActivatedProtocolFeatures map[string][]HexBytes `json:"activated_protocol_features,omitempty"`

	SignedBlock *SignedBlock `json:"block,omitempty"`
	Validated   bool         `json:"validated"`
}

type BlockTimestamp

type BlockTimestamp struct {
	time.Time
}

func (BlockTimestamp) MarshalJSON

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

func (*BlockTimestamp) UnmarshalJSON

func (t *BlockTimestamp) UnmarshalJSON(data []byte) (err error)

type Bool

type Bool bool

func (*Bool) UnmarshalJSON

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

type ChainSizeMessage

type ChainSizeMessage struct {
	LastIrreversibleBlockNum uint32      `json:"last_irreversible_block_num"`
	LastIrreversibleBlockID  Checksum256 `json:"last_irreversible_block_id"`
	HeadNum                  uint32      `json:"head_num"`
	HeadID                   Checksum256 `json:"head_id"`
}

func (*ChainSizeMessage) GetType

func (m *ChainSizeMessage) GetType() P2PMessageType

type Checksum160

type Checksum160 []byte

func (Checksum160) MarshalJSON

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

func (*Checksum160) UnmarshalJSON

func (t *Checksum160) UnmarshalJSON(data []byte) (err error)

type Checksum256

type Checksum256 []byte

func (Checksum256) MarshalJSON

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

func (Checksum256) String

func (t Checksum256) String() string

func (*Checksum256) UnmarshalJSON

func (t *Checksum256) UnmarshalJSON(data []byte) (err error)

type Checksum512

type Checksum512 []byte

func (Checksum512) MarshalJSON

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

func (*Checksum512) UnmarshalJSON

func (t *Checksum512) UnmarshalJSON(data []byte) (err error)

type ClausePair

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

ClausePair represents clauses, related to Ricardian Contracts.

type CompressionType

type CompressionType uint8

func (CompressionType) MarshalJSON

func (c CompressionType) MarshalJSON() ([]byte, error)

func (CompressionType) String

func (c CompressionType) String() string

func (*CompressionType) UnmarshalJSON

func (c *CompressionType) UnmarshalJSON(data []byte) error

type ControlledAccountsResp

type ControlledAccountsResp struct {
	ControlledAccounts []string `json:"controlled_accounts"`
}

type CreateSnapshotResp

type CreateSnapshotResp struct {
	SnapshotName string `json:"snapshot_name"`
	HeadBlockID  string `json:"head_block_id"`
}

type Currency

type Currency struct {
	Precision uint8
	Name      CurrencyName
}

type CurrencyBalanceResp

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

type CurrencyName string

type DBSizeResp

type DBSizeResp struct {
	FreeBytes Int64 `json:"free_bytes"`
	UsedBytes Int64 `json:"used_bytes"`
	Size      Int64 `json:"size"`
	Indices   []struct {
		Index    string `json:"index"`
		RowCount Int64  `json:"row_count"`
	} `json:"indices"`
}

type DataAccess

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

type DecodeOption

type DecodeOption = interface{}

type Decoder

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

Decoder implements the EOS unpacking, similar to FC_BUFFER

func NewDecoder

func NewDecoder(data []byte) *Decoder

func (*Decoder) Decode

func (d *Decoder) Decode(v interface{}, options ...DecodeOption) (err error)

func (*Decoder) DecodeActions

func (d *Decoder) DecodeActions(decode bool)

func (*Decoder) DecodeP2PMessage

func (d *Decoder) DecodeP2PMessage(decode bool)

func (*Decoder) ReadActionData

func (d *Decoder) ReadActionData(action *Action) (err error)

func (*Decoder) ReadAsset

func (d *Decoder) ReadAsset() (out Asset, err error)

func (*Decoder) ReadBlockTimestamp

func (d *Decoder) ReadBlockTimestamp() (out BlockTimestamp, err error)

func (*Decoder) ReadBool

func (d *Decoder) ReadBool() (out bool, err error)

func (*Decoder) ReadByte

func (d *Decoder) ReadByte() (out byte, err error)

func (*Decoder) ReadByteArray

func (d *Decoder) ReadByteArray() (out []byte, err error)

func (*Decoder) ReadChecksum160

func (d *Decoder) ReadChecksum160() (out Checksum160, err error)

func (*Decoder) ReadChecksum256

func (d *Decoder) ReadChecksum256() (out Checksum256, err error)

func (*Decoder) ReadChecksum512

func (d *Decoder) ReadChecksum512() (out Checksum512, err error)

func (*Decoder) ReadCurrencyName

func (d *Decoder) ReadCurrencyName() (out CurrencyName, err error)

func (*Decoder) ReadExtendedAsset

func (d *Decoder) ReadExtendedAsset() (out ExtendedAsset, err error)

func (*Decoder) ReadFloat32

func (d *Decoder) ReadFloat32() (out float32, err error)

func (*Decoder) ReadFloat64

func (d *Decoder) ReadFloat64() (out float64, err error)

func (*Decoder) ReadInt16

func (d *Decoder) ReadInt16() (out int16, err error)

func (*Decoder) ReadInt32

func (d *Decoder) ReadInt32() (out int32, err error)

func (*Decoder) ReadInt64

func (d *Decoder) ReadInt64() (out int64, err error)

func (*Decoder) ReadInt8

func (d *Decoder) ReadInt8() (out int8, err error)

func (*Decoder) ReadJSONTime

func (d *Decoder) ReadJSONTime() (jsonTime JSONTime, err error)

func (*Decoder) ReadName

func (d *Decoder) ReadName() (out Name, err error)

func (*Decoder) ReadP2PMessageEnvelope

func (d *Decoder) ReadP2PMessageEnvelope() (out *Packet, err error)

func (*Decoder) ReadPublicKey

func (d *Decoder) ReadPublicKey() (out ecc.PublicKey, err error)

func (*Decoder) ReadSignature

func (d *Decoder) ReadSignature() (out ecc.Signature, err error)

func (*Decoder) ReadString

func (d *Decoder) ReadString() (out string, err error)

func (*Decoder) ReadSymbol

func (d *Decoder) ReadSymbol() (out *Symbol, err error)

func (*Decoder) ReadSymbolCode

func (d *Decoder) ReadSymbolCode() (out SymbolCode, err error)

func (*Decoder) ReadTimePoint

func (d *Decoder) ReadTimePoint() (out TimePoint, err error)

func (*Decoder) ReadTimePointSec

func (d *Decoder) ReadTimePointSec() (out TimePointSec, err error)

func (*Decoder) ReadTstamp

func (d *Decoder) ReadTstamp() (out Tstamp, err error)

func (*Decoder) ReadUInt8

func (d *Decoder) ReadUInt8() (out uint8, err error)

Deprecated: Use `ReadUint8` (with a lower case `i`) instead

func (*Decoder) ReadUint128

func (d *Decoder) ReadUint128(typeName string) (out Uint128, err error)

func (*Decoder) ReadUint16

func (d *Decoder) ReadUint16() (out uint16, err error)

func (*Decoder) ReadUint32

func (d *Decoder) ReadUint32() (out uint32, err error)

func (*Decoder) ReadUint64

func (d *Decoder) ReadUint64() (out uint64, err error)

func (*Decoder) ReadUint8

func (d *Decoder) ReadUint8() (out uint8, err error)

func (*Decoder) ReadUvarint32

func (d *Decoder) ReadUvarint32() (out uint32, err error)

func (*Decoder) ReadUvarint64

func (d *Decoder) ReadUvarint64() (uint64, error)

func (*Decoder) ReadVarint32

func (d *Decoder) ReadVarint32() (out int32, err error)

func (*Decoder) ReadVarint64

func (d *Decoder) ReadVarint64() (out int64, err error)

type DeferredTransaction

type DeferredTransaction struct {
	*Transaction

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

type DelegatedBandwidth

type DelegatedBandwidth struct {
	From      AccountName `json:"from"`
	To        AccountName `json:"to"`
	NetWeight Asset       `json:"net_weight"`
	CPUWeight Asset       `json:"cpu_weight"`
}

type EOSNameOrUint32

type EOSNameOrUint32 interface{}

type Encoder

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

-------------------------------------------------------------- Encoder implements the EOS packing, similar to FC_BUFFER --------------------------------------------------------------

func NewEncoder

func NewEncoder(w io.Writer) *Encoder

func (*Encoder) Encode

func (e *Encoder) Encode(v interface{}) (err error)

type Except

type Except struct {
	Code    int                 `json:"code"`
	Name    string              `json:"name"`
	Message string              `json:"message"`
	Stack   []*ExceptLogMessage `json:"stack"`
}

type ExceptLogContext

type ExceptLogContext struct {
	Level      string            `json:"level"` // "debug", "info", "warn", "error", also: "all", "off"
	File       string            `json:"file"`
	Line       int               `json:"line"`
	Method     string            `json:"method"`
	Hostname   string            `json:"hostname"`
	ThreadName string            `json:"thread_name"`
	Timestamp  JSONTime          `json:"timestamp"`
	Context    *ExceptLogContext `json:"context,omitempty"`
}

type ExceptLogMessage

type ExceptLogMessage struct {
	Context ExceptLogContext `json:"context"`
	Format  string           `json:"format"`
	Data    json.RawMessage  `json:"data"`
}

LogMessage is a line of message in an exception.

type ExtendedAsset

type ExtendedAsset struct {
	Asset    Asset `json:"asset"`
	Contract AccountName
}

type Extension

type Extension struct {
	Type uint16
	Data HexBytes
}

func (*Extension) AsBlockHeaderExtension

func (e *Extension) AsBlockHeaderExtension(chain string) (BlockHeaderExtension, error)

AsBlockHeaderExtension turns the given `Extension` object into one of the known `BlockHeaderExtension` concrete type.

func (*Extension) MarshalJSON

func (e *Extension) MarshalJSON() ([]byte, error)

func (*Extension) UnmarshalJSON

func (e *Extension) UnmarshalJSON(data []byte) error

type FieldDef

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

type Float128

type Float128 Uint128

func (Float128) MarshalJSON

func (i Float128) MarshalJSON() (data []byte, err error)

func (*Float128) UnmarshalJSON

func (i *Float128) UnmarshalJSON(data []byte) error

type GetABIResp

type GetABIResp struct {
	AccountName AccountName `json:"account_name"`
	ABI         ABI         `json:"abi"`
}

type GetActionsRequest

type GetActionsRequest struct {
	AccountName AccountName `json:"account_name"`
	Pos         Int64       `json:"pos"`
	Offset      Int64       `json:"offset"`
}

type GetCodeHashResp

type GetCodeHashResp struct {
	AccountName AccountName `json:"account_name"`
	CodeHash    string      `json:"code_hash"`
}

type GetCodeResp

type GetCodeResp struct {
	AccountName AccountName `json:"account_name"`
	CodeHash    string      `json:"code_hash"`
	WASM        string      `json:"wasm"`
	ABI         ABI         `json:"abi"`
}

type GetCurrencyStatsResp

type GetCurrencyStatsResp struct {
	Supply    Asset       `json:"supply"`
	MaxSupply Asset       `json:"max_supply"`
	Issuer    AccountName `json:"issuer"`
}

type GetIntegrityHashResp

type GetIntegrityHashResp struct {
	HeadBlockID  string `json:"head_block_id"`
	SnapshotName string `json:"integrity_hash"`
}

type GetRawABIRequest

type GetRawABIRequest struct {
	AccountName string      `json:"account_name"`
	ABIHash     Checksum256 `json:"abi_hash,omitempty"`
}

type GetRawABIResp

type GetRawABIResp struct {
	AccountName string      `json:"account_name"`
	CodeHash    Checksum256 `json:"code_hash"`
	ABIHash     Checksum256 `json:"abi_hash"`
	ABI         Blob        `json:"abi"`
}

type GetRawCodeAndABIResp

type GetRawCodeAndABIResp struct {
	AccountName  AccountName `json:"account_name"`
	WASMasBase64 string      `json:"wasm"`
	ABIasBase64  string      `json:"abi"`
}

type GetRequiredKeysResp

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

type GetTableByScopeRequest

type GetTableByScopeRequest struct {
	Code       string `json:"code"`
	Table      string `json:"table"`
	LowerBound string `json:"lower_bound,omitempty"`
	UpperBound string `json:"upper_bound,omitempty"`
	Limit      uint32 `json:"limit,omitempty"`
}

type GetTableByScopeResp

type GetTableByScopeResp struct {
	More bool            `json:"more"`
	Rows json.RawMessage `json:"rows"`
}

type GetTableRowsRequest

type GetTableRowsRequest struct {
	Code       string `json:"code"` // Contract "code" account where table lives
	Scope      string `json:"scope"`
	Table      string `json:"table"`
	LowerBound string `json:"lower_bound,omitempty"`
	UpperBound string `json:"upper_bound,omitempty"`
	Limit      uint32 `json:"limit,omitempty"`          // defaults to 10 => chain_plugin.hpp:struct get_table_rows_params
	KeyType    string `json:"key_type,omitempty"`       // The key type of --index, primary only supports (i64), all others support (i64, i128, i256, float64, float128, ripemd160, sha256). Special type 'name' indicates an account name.
	Index      string `json:"index_position,omitempty"` // Index number, 1 - primary (first), 2 - secondary index (in order defined by multi_index), 3 - third index, etc. Number or name of index can be specified, e.g. 'secondary' or '2'.
	EncodeType string `json:"encode_type,omitempty"`    // The encoding type of key_type (i64 , i128 , float64, float128) only support decimal encoding e.g. 'dec'" "i256 - supports both 'dec' and 'hex', ripemd160 and sha256 is 'hex' only
	JSON       bool   `json:"json"`                     // JSON output if true, binary if false
}

type GetTableRowsResp

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

func (*GetTableRowsResp) BinaryToStructs

func (resp *GetTableRowsResp) BinaryToStructs(v interface{}) error

func (*GetTableRowsResp) JSONToStructs

func (resp *GetTableRowsResp) JSONToStructs(v interface{}) error

type Global

type Global struct {
	MaxBlockNetUsage               int     `json:"max_block_net_usage"`
	TargetBlockNetUsagePct         int     `json:"target_block_net_usage_pct"`
	MaxTransactionNetUsage         int     `json:"max_transaction_net_usage"`
	BasePerTransactionNetUsage     int     `json:"base_per_transaction_net_usage"`
	NetUsageLeeway                 int     `json:"net_usage_leeway"`
	ContextFreeDiscountNetUsageNum int     `json:"context_free_discount_net_usage_num"`
	ContextFreeDiscountNetUsageDen int     `json:"context_free_discount_net_usage_den"`
	MaxBlockCPUUsage               int     `json:"max_block_cpu_usage"`
	TargetBlockCPUUsagePct         int     `json:"target_block_cpu_usage_pct"`
	MaxTransactionCPUUsage         int     `json:"max_transaction_cpu_usage"`
	MinTransactionCPUUsage         int     `json:"min_transaction_cpu_usage"`
	MaxTransactionLifetime         int     `json:"max_transaction_lifetime"`
	DeferredTrxExpirationWindow    int     `json:"deferred_trx_expiration_window"`
	MaxTransactionDelay            int     `json:"max_transaction_delay"`
	MaxInlineActionSize            int     `json:"max_inline_action_size"`
	MaxInlineActionDepth           int     `json:"max_inline_action_depth"`
	MaxAuthorityDepth              int     `json:"max_authority_depth"`
	MaxRAMSize                     string  `json:"max_ram_size"`
	TotalRAMBytesReserved          Int64   `json:"total_ram_bytes_reserved"`
	TotalRAMStake                  Int64   `json:"total_ram_stake"`
	LastProducerScheduleUpdate     string  `json:"last_producer_schedule_update"`
	LastPervoteBucketFill          Int64   `json:"last_pervote_bucket_fill,string"`
	PervoteBucket                  int     `json:"pervote_bucket"`
	PerblockBucket                 int     `json:"perblock_bucket"`
	TotalUnpaidBlocks              int     `json:"total_unpaid_blocks"`
	TotalActivatedStake            float64 `json:"total_activated_stake,string"`
	ThreshActivatedStakeTime       Int64   `json:"thresh_activated_stake_time,string"`
	LastProducerScheduleSize       int     `json:"last_producer_schedule_size"`
	TotalProducerVoteWeight        float64 `json:"total_producer_vote_weight,string"`
	LastNameClose                  string  `json:"last_name_close"`
}

type GoAwayMessage

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

func (*GoAwayMessage) GetType

func (m *GoAwayMessage) GetType() P2PMessageType

func (*GoAwayMessage) String

func (m *GoAwayMessage) String() string

type GoAwayReason

type GoAwayReason uint8

func (GoAwayReason) String

func (r GoAwayReason) String() string

type HandshakeMessage

type HandshakeMessage struct {
	// net_plugin/protocol.hpp handshake_message
	NetworkVersion           uint16        `json:"network_version"`
	ChainID                  Checksum256   `json:"chain_id"`
	NodeID                   Checksum256   `json:"node_id"` // sha256
	Key                      ecc.PublicKey `json:"key"`     // can be empty, producer key, or peer key
	Time                     Tstamp        `json:"time"`    // time?!
	Token                    Checksum256   `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  Checksum256   `json:"last_irreversible_block_id"`
	HeadNum                  uint32        `json:"head_num"`
	HeadID                   Checksum256   `json:"head_id"`
	OS                       string        `json:"os"`
	Agent                    string        `json:"agent"`
	Generation               int16         `json:"generation"`
}

func (*HandshakeMessage) GetType

func (m *HandshakeMessage) GetType() P2PMessageType

func (*HandshakeMessage) String

func (m *HandshakeMessage) String() string

type HexBytes

type HexBytes []byte

func (HexBytes) MarshalJSON

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

func (HexBytes) String

func (t HexBytes) String() string

func (*HexBytes) UnmarshalJSON

func (t *HexBytes) UnmarshalJSON(data []byte) (err error)

type IDListMode

type IDListMode byte

type InfoResp

type InfoResp struct {
	ServerVersion            string         `json:"server_version"` // "2cc40a4e"
	ChainID                  Checksum256    `json:"chain_id"`
	HeadBlockNum             uint32         `json:"head_block_num"`              // 2465669,
	LastIrreversibleBlockNum uint32         `json:"last_irreversible_block_num"` // 2465655
	LastIrreversibleBlockID  Checksum256    `json:"last_irreversible_block_id"`  // "00000008f98f0580d7efe7abc60abaaf8a865c9428a4267df30ff7d1937a1084"
	HeadBlockID              Checksum256    `json:"head_block_id"`               // "00259f856bfa142d1d60aff77e70f0c4f3eab30789e9539d2684f9f8758f1b88",
	HeadBlockTime            BlockTimestamp `json:"head_block_time"`             //  "2018-02-02T04:19:32"
	HeadBlockProducer        AccountName    `json:"head_block_producer"`         // "inita"

	VirtualBlockCPULimit Int64  `json:"virtual_block_cpu_limit"`
	VirtualBlockNetLimit Int64  `json:"virtual_block_net_limit"`
	BlockCPULimit        Int64  `json:"block_cpu_limit"`
	BlockNetLimit        Int64  `json:"block_net_limit"`
	ServerVersionString  string `json:"server_version_string"`
}

type Int128

type Int128 Uint128

func (Int128) MarshalJSON

func (i Int128) MarshalJSON() (data []byte, err error)

func (*Int128) UnmarshalJSON

func (i *Int128) UnmarshalJSON(data []byte) error

type Int64

type Int64 int64

func (Int64) MarshalJSON

func (i Int64) MarshalJSON() (data []byte, err error)

func (*Int64) UnmarshalJSON

func (i *Int64) UnmarshalJSON(data []byte) error

type JSONFloat64

type JSONFloat64 float64

func (*JSONFloat64) UnmarshalJSON

func (f *JSONFloat64) UnmarshalJSON(data []byte) error

type JSONInt64

type JSONInt64 = Int64

JSONInt64 is deprecated in favor of Int64.

type JSONTime

type JSONTime struct {
	time.Time
}

func ParseJSONTime

func ParseJSONTime(date string) (JSONTime, error)

ParseJSONTime will parse a string into a JSONTime object

func (JSONTime) MarshalJSON

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

func (*JSONTime) UnmarshalJSON

func (t *JSONTime) UnmarshalJSON(data []byte) (err error)

type KeyAccountsResp

type KeyAccountsResp struct {
	AccountNames []string `json:"account_names"`
}

type KeyBag

type KeyBag struct {
	Keys []*ecc.PrivateKey `json:"keys"`
}

KeyBag holds private keys in memory, for signing transactions.

func NewKeyBag

func NewKeyBag() *KeyBag

func (*KeyBag) Add

func (b *KeyBag) Add(wifKey string) error

func (*KeyBag) AvailableKeys

func (b *KeyBag) AvailableKeys() (out []ecc.PublicKey, err error)

func (*KeyBag) ImportFromFile

func (b *KeyBag) ImportFromFile(path string) error

func (*KeyBag) ImportPrivateKey

func (b *KeyBag) ImportPrivateKey(wifPrivKey string) (err error)

func (*KeyBag) Sign

func (b *KeyBag) Sign(tx *SignedTransaction, chainID []byte, requiredKeys ...ecc.PublicKey) (*SignedTransaction, error)

func (*KeyBag) SignDigest

func (b *KeyBag) SignDigest(digest []byte, requiredKey ecc.PublicKey) (ecc.Signature, error)

type KeyWeight

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

type M

type M map[string]interface{}

type MerkleRoot

type MerkleRoot struct {
	ActiveNodes []string `json:"_active_nodes"`
	NodeCount   uint32   `json:"_node_count"`
}

type MessageReflectTypes

type MessageReflectTypes struct {
	Name        string
	ReflectType reflect.Type
}

type MyStruct

type MyStruct struct {
	Currency
	Balance Uint64
}

type Name

type Name string

type NetConnectResp

type NetConnectResp string

type NetConnectionsResp

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

NetConnectionResp

type NetDisconnectResp

type NetDisconnectResp string

type NetStatusResp

type NetStatusResp struct {
}

type NoticeMessage

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

func (*NoticeMessage) GetType

func (m *NoticeMessage) GetType() P2PMessageType

func (*NoticeMessage) String

func (n *NoticeMessage) String() string

type OnVariant

type OnVariant = func(impl interface{}) error

type OrderedBlockIDs

type OrderedBlockIDs struct {
	Mode    [4]byte       `json:"mode"`
	Pending uint32        `json:"pending"`
	IDs     []Checksum256 `json:"ids"`
}

func (*OrderedBlockIDs) String

func (o *OrderedBlockIDs) String() string

type OrderedTransactionIDs

type OrderedTransactionIDs struct {
	Mode    [4]byte       `json:"mode"`
	Pending uint32        `json:"pending"`
	IDs     []Checksum256 `json:"ids"`
}

type P2PMessage

type P2PMessage interface {
	fmt.Stringer
	GetType() P2PMessageType
}

type P2PMessageType

type P2PMessageType byte
const (
	HandshakeMessageType P2PMessageType = iota // 0
	ChainSizeType
	GoAwayMessageType // 2
	TimeMessageType
	NoticeMessageType // 4
	RequestMessageType
	SyncRequestMessageType       // 6
	SignedBlockType              // 7
	PackedTransactionMessageType // 8
)

func NewMessageType

func NewMessageType(aType byte) (t P2PMessageType, err error)

func (P2PMessageType) Name

func (t P2PMessageType) Name() (string, bool)

type PackedTransaction

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"`
	// contains filtered or unexported fields
}

PackedTransaction represents a fully packed transaction, with signatures, and all. They circulate like that on the P2P net, and that's how they are stored.

func (*PackedTransaction) ID

func (p *PackedTransaction) ID() (Checksum256, error)

ID returns the hash of a transaction.

func (*PackedTransaction) Unpack

func (p *PackedTransaction) Unpack() (signedTx *SignedTransaction, err error)

Unpack decodes the bytestream of the transaction, and attempts to decode the registered actions.

Example

Code:

package main

import (
	"encoding/json"
	"fmt"

	eos "github.com/aurawing/eos-go"
)

func main() {
	var packedTrx *eos.PackedTransaction
	err := json.Unmarshal(packedTrxData(), &packedTrx)
	if err != nil {
		panic(fmt.Errorf("unmarshaling to PackedTransaction: %s", err))
	}

	var signedTrx *eos.SignedTransaction
	signedTrx, err = packedTrx.Unpack()
	if err != nil {
		panic(fmt.Errorf("unpacking transaction: %s", err))
	}

	fmt.Printf("%#v\n", signedTrx.Actions)
}

func packedTrxData() []byte {
	return []byte(`
		{
		"signatures": [
		  "SIG_K1_K8VSYk76oK4Hdy23UtAJwwRHtBNP8mbu8uo9TVKsT3si5cujPbRqif8eqxqTwLbKREDFm7eK7YG3skLg9LVXZ54KrEoTuJ"
		],
		"compression": "none",
		"packed_context_free_data": "",
		"packed_trx": "a67a815c0d358ee0065800000000011082422e6575305500405647ed48b1ba0140a7c3066575305500000000489aa6b94a1c88ee2531ab18a800201ee9053cde8078023ba1229389f58a0c72ef7fe9ee942e6be7705021630a03e206b016a9711064ee11cc894100701a1160f12c37000903729a1b60f3c7b0117900"
	  }
	`)
}

func (*PackedTransaction) UnpackBare

func (p *PackedTransaction) UnpackBare() (signedTx *SignedTransaction, err error)

UnpackBare decodes the transcation payload, but doesn't decode the nested action data structure. See also `Unpack`.

type PackedTransactionMessage

type PackedTransactionMessage struct {
	PackedTransaction
}

func (*PackedTransactionMessage) GetType

func (m *PackedTransactionMessage) GetType() P2PMessageType

func (PackedTransactionMessage) String

func (m PackedTransactionMessage) String() string

type Packet

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

func ReadPacket

func ReadPacket(r io.Reader) (packet *Packet, err error)

type PendingSchedule

type PendingSchedule struct {
	ScheduleLIBNum uint32                               `json:"schedule_lib_num"`
	ScheduleHash   HexBytes                             `json:"schedule_hash"`
	Schedule       *ProducerScheduleOrAuthoritySchedule `json:"schedule"`
}

type Permission

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

type PermissionLevel

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

func NewPermissionLevel

func NewPermissionLevel(in string) (out PermissionLevel, err error)

NewPermissionLevel parses strings like `account@active`, `otheraccount@owner` and builds a PermissionLevel struct. It validates that there is a single optional @ (where permission defaults to 'active'), and validates length of account and permission names.

type PermissionLevelWeight

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

type PermissionName

type PermissionName Name

func PN

func PN(in string) PermissionName

type ProcessedTransaction

type ProcessedTransaction struct {
	Transaction SignedTransaction `json:"trx"`
}

type Producer

type Producer struct {
	Owner         string      `json:"owner"`
	TotalVotes    float64     `json:"total_votes,string"`
	ProducerKey   string      `json:"producer_key"`
	IsActive      int         `json:"is_active"`
	URL           string      `json:"url"`
	UnpaidBlocks  int         `json:"unpaid_blocks"`
	LastClaimTime JSONFloat64 `json:"last_claim_time"`
	Location      int         `json:"location"`
}

type ProducerAuthority

type ProducerAuthority struct {
	AccountName           AccountName            `json:"producer_name"`
	BlockSigningAuthority *BlockSigningAuthority `json:"authority"`
}

type ProducerAuthoritySchedule

type ProducerAuthoritySchedule struct {
	Version   uint32               `json:"version"`
	Producers []*ProducerAuthority `json:"producers"`
}

type ProducerChange

type ProducerChange struct {
}

type ProducerKey

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

type ProducerSchedule

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

type ProducerScheduleChangeExtension

type ProducerScheduleChangeExtension struct {
	ProducerAuthoritySchedule
}

ProducerScheduleChangeExtension is a block header extension present in the signed block when a new producer authority schedule should be applied.

func (*ProducerScheduleChangeExtension) TypeID

func (e *ProducerScheduleChangeExtension) TypeID() BlockHeaderExtensionType

type ProducerScheduleOrAuthoritySchedule

type ProducerScheduleOrAuthoritySchedule struct {
	// EOSIO 1.x
	V1 *ProducerSchedule

	// EOSIO 2.x
	V2 *ProducerAuthoritySchedule
}

func (*ProducerScheduleOrAuthoritySchedule) MarshalJSON

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

func (*ProducerScheduleOrAuthoritySchedule) UnmarshalJSON

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

type ProducersResp

type ProducersResp struct {
	Producers []Producer `json:"producers"`
}

type ProtocolFeatureActivationExtension

type ProtocolFeatureActivationExtension struct {
	FeatureDigests []Checksum256 `json:"protocol_features"`
}

ProtocolFeatureActivationExtension is a block header extension present in the signed block when a particular set of protocol features has been activated by this blockl.

func (*ProtocolFeatureActivationExtension) TypeID

func (e *ProtocolFeatureActivationExtension) TypeID() BlockHeaderExtensionType

type PushTransactionFullResp

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

PushTransactionFullResp unwraps the responses from a successful `push_transaction`. FIXME: REVIEW the actual output, things have moved here.

type PushTransactionShortResp

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

type RefundRequest

type RefundRequest struct {
	Owner       AccountName `json:"owner"`
	RequestTime JSONTime    `json:"request_time"` //         {"name":"request_time", "type":"time_point_sec"},
	NetAmount   Asset       `json:"net_amount"`
	CPUAmount   Asset       `json:"cpu_amount"`
}

type RequestMessage

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

func (*RequestMessage) GetType

func (m *RequestMessage) GetType() P2PMessageType

func (*RequestMessage) String

func (r *RequestMessage) String() string

type SHA256Bytes

type SHA256Bytes = Checksum256

SHA256Bytes is deprecated and renamed to Checksum256 for consistency. Please update your code as this type will eventually be phased out.

type ScheduledTransaction

type ScheduledTransaction struct {
	TransactionID Checksum256 `json:"trx_id"`
	Sender        AccountName `json:"sender"`
	SenderID      string      `json:"sender_id"`
	Payer         AccountName `json:"payer"`
	DelayUntil    JSONTime    `json:"delay_until"`
	Expiration    JSONTime    `json:"expiration"`
	Published     JSONTime    `json:"published"`

	Transaction *Transaction `json:"transaction"`
}

type ScheduledTransactionsResp

type ScheduledTransactionsResp struct {
	Transactions []ScheduledTransaction `json:"transactions"`
	More         string                 `json:"more"`
}

type ScopeName

type ScopeName Name

type SequencedTransactionResp

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

type SetABI

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

SetABI represents the hard-coded `setabi` action.

type SetCode

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

SetCode represents the hard-coded `setcode` action.

type SignedBlock

type SignedBlock struct {
	SignedBlockHeader
	Transactions    []TransactionReceipt `json:"transactions"`
	BlockExtensions []*Extension         `json:"block_extensions"`
}

func (*SignedBlock) GetType

func (m *SignedBlock) GetType() P2PMessageType

func (*SignedBlock) String

func (m *SignedBlock) String() string

type SignedBlockHeader

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

type SignedTransaction

type SignedTransaction struct {
	*Transaction

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

func NewSignedTransaction

func NewSignedTransaction(tx *Transaction) *SignedTransaction

func (*SignedTransaction) Pack

func (s *SignedTransaction) Pack(compression CompressionType) (*PackedTransaction, error)

func (*SignedTransaction) PackedTransactionAndCFD

func (s *SignedTransaction) PackedTransactionAndCFD() ([]byte, []byte, error)

func (*SignedTransaction) SignedByKeys

func (s *SignedTransaction) SignedByKeys(chainID Checksum256) (out []ecc.PublicKey, err error)

func (*SignedTransaction) String

func (s *SignedTransaction) String() string

type SignedTransactionMessage

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

type Signer

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

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

type Symbol

type Symbol struct {
	Precision uint8
	Symbol    string
	// contains filtered or unexported fields
}

NOTE: there's also a new ExtendedSymbol (which includes the contract (as AccountName) on which it is)

func MustStringToSymbol

func MustStringToSymbol(str string) Symbol

func NameToSymbol

func NameToSymbol(name Name) (Symbol, error)

func NewSymbolFromUint64

func NewSymbolFromUint64(value uint64) (out Symbol)

func StringToSymbol

func StringToSymbol(str string) (Symbol, error)

func (Symbol) MustSymbolCode

func (s Symbol) MustSymbolCode() SymbolCode

func (Symbol) String

func (s Symbol) String() string

func (Symbol) SymbolCode

func (s Symbol) SymbolCode() (SymbolCode, error)

func (Symbol) ToName

func (s Symbol) ToName() (string, error)

func (Symbol) ToUint64

func (s Symbol) ToUint64() (uint64, error)

type SymbolCode

type SymbolCode uint64

func NameToSymbolCode

func NameToSymbolCode(name Name) (SymbolCode, error)

func StringToSymbolCode

func StringToSymbolCode(str string) (SymbolCode, error)

func (SymbolCode) MarshalJSON

func (sc SymbolCode) MarshalJSON() (data []byte, err error)

func (SymbolCode) String

func (sc SymbolCode) String() string

func (SymbolCode) ToName

func (sc SymbolCode) ToName() string

type SyncRequestMessage

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

func (*SyncRequestMessage) GetType

func (m *SyncRequestMessage) GetType() P2PMessageType

func (*SyncRequestMessage) String

func (m *SyncRequestMessage) String() string

type TableDef

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"`
}

TableDef defines a table. See libraries/chain/include/eosio/chain/contracts/types.hpp:78

type TableName

type TableName Name

type TimeMessage

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

func (*TimeMessage) GetType

func (m *TimeMessage) GetType() P2PMessageType

func (*TimeMessage) String

func (t *TimeMessage) String() string

type TimePoint

type TimePoint uint64

TimePoint represents the number of microseconds since EPOCH (Jan 1st 1970)

type TimePointSec

type TimePointSec uint32

TimePointSec represents the number of seconds since EPOCH (Jan 1st 1970)

type TotalResources

type TotalResources struct {
	Owner     AccountName `json:"owner"`
	NetWeight Asset       `json:"net_weight"`
	CPUWeight Asset       `json:"cpu_weight"`
	RAMBytes  Int64       `json:"ram_bytes"`
}

type Trace

type Trace 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"`
	DataAccess []DataAccess `json:"data_access"`
}

type Transaction

type Transaction struct {
	TransactionHeader

	ContextFreeActions []*Action    `json:"context_free_actions"`
	Actions            []*Action    `json:"actions"`
	Extensions         []*Extension `json:"transaction_extensions"`
}

func NewTransaction

func NewTransaction(actions []*Action, opts *TxOptions) *Transaction

NewTransaction creates a transaction. Unless you plan on adding HeadBlockID later, to be complete, opts should contain it. Sign

func (*Transaction) Fill

func (tx *Transaction) Fill(headBlockID Checksum256, delaySecs, maxNetUsageWords uint32, maxCPUUsageMS uint8)

Fill sets the fields on a transaction. If you pass `headBlockID`, then `api` can be nil. If you don't pass `headBlockID`, then the `api` is going to be called to fetch

func (*Transaction) SetExpiration

func (tx *Transaction) SetExpiration(in time.Duration)

type TransactionHeader

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

	MaxNetUsageWords Varuint32 `json:"max_net_usage_words"`
	MaxCPUUsageMS    uint8     `json:"max_cpu_usage_ms"`
	DelaySec         Varuint32 `json:"delay_sec"` // number of secs to delay, making it cancellable for that duration
}

type TransactionProcessed

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

type TransactionReceipt

type TransactionReceipt struct {
	TransactionReceiptHeader
	Transaction TransactionWithID `json:"trx"`
}

type TransactionReceiptHeader

type TransactionReceiptHeader struct {
	Status               TransactionStatus `json:"status"`
	CPUUsageMicroSeconds uint32            `json:"cpu_usage_us"`
	NetUsageWords        Varuint32         `json:"net_usage_words"`
}

type TransactionResp

type TransactionResp struct {
	ID      Checksum256 `json:"id"`
	Receipt struct {
		Status            TransactionStatus `json:"status"`
		CPUUsageMicrosec  int               `json:"cpu_usage_us"`
		NetUsageWords     int               `json:"net_usage_words"`
		PackedTransaction TransactionWithID `json:"trx"`
	} `json:"receipt"`
	Transaction           ProcessedTransaction `json:"trx"`
	BlockTime             BlockTimestamp       `json:"block_time"`
	BlockNum              uint32               `json:"block_num"`
	LastIrreversibleBlock uint32               `json:"last_irreversible_block"`
	Traces                []ActionTrace        `json:"traces"`
}

type TransactionStatus

type TransactionStatus uint8
const (
	TransactionStatusExecuted TransactionStatus = iota ///< succeed, no error handler executed
	TransactionStatusSoftFail                          ///< objectively failed (not executed), error handler executed
	TransactionStatusHardFail                          ///< objectively failed and error handler objectively failed thus no state change
	TransactionStatusDelayed                           ///< transaction delayed
	TransactionStatusExpired                           ///< transaction expired
	TransactionStatusUnknown  = TransactionStatus(255)
)

func (TransactionStatus) MarshalJSON

func (s TransactionStatus) MarshalJSON() (data []byte, err error)

func (TransactionStatus) String

func (s TransactionStatus) String() string

func (*TransactionStatus) UnmarshalJSON

func (s *TransactionStatus) UnmarshalJSON(data []byte) error

type TransactionTrace

type TransactionTrace struct {
	ID              Checksum256               `json:"id"`
	BlockNum        uint32                    `json:"block_num"`
	BlockTime       BlockTimestamp            `json:"block_time"`
	ProducerBlockID Checksum256               `json:"producer_block_id"`
	Receipt         *TransactionReceiptHeader `json:"receipt,omitempty"`
	Elapsed         Int64                     `json:"elapsed"`
	NetUsage        Uint64                    `json:"net_usage"`
	Scheduled       bool                      `json:"scheduled"`
	ActionTraces    []ActionTrace             `json:"action_traces"`
	AccountRamDelta *struct {
		AccountName AccountName `json:"account_name"`
		Delta       Int64       `json:"delta"`
	} `json:"account_ram_delta"`
	Except          *Except           `json:"except"`
	ErrorCode       *Uint64           `json:"error_code"`
	FailedDtrxTrace *TransactionTrace `json:"failed_dtrx_trace"`
}

type TransactionTraceAuthSequence

type TransactionTraceAuthSequence struct {
	Account  AccountName
	Sequence Uint64
}

func (TransactionTraceAuthSequence) MarshalJSON

func (auth TransactionTraceAuthSequence) MarshalJSON() (data []byte, err error)

func (*TransactionTraceAuthSequence) UnmarshalJSON

func (auth *TransactionTraceAuthSequence) UnmarshalJSON(data []byte) error

[ ["account", 123123], ["account2", 345] ]

type TransactionWithID

type TransactionWithID struct {
	ID     Checksum256
	Packed *PackedTransaction
}

func (TransactionWithID) MarshalJSON

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

func (*TransactionWithID) UnmarshalJSON

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

type TransactionsResp

type TransactionsResp struct {
	Transactions []SequencedTransactionResp
}

type Tstamp

type Tstamp struct {
	time.Time
}

func (Tstamp) MarshalJSON

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

func (*Tstamp) UnmarshalJSON

func (t *Tstamp) UnmarshalJSON(data []byte) (err error)

type TxOptions

type TxOptions struct {
	ChainID          Checksum256 // If specified, we won't hit the API to fetch it
	HeadBlockID      Checksum256 // If provided, don't hit API to fetch it.  This allows offline transaction signing.
	MaxNetUsageWords uint32
	DelaySecs        uint32
	MaxCPUUsageMS    uint8 // 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
}

TxOptions represents options you want to pass to the transaction you're sending.

func (*TxOptions) FillFromChain

func (opts *TxOptions) FillFromChain(api *API) error

FillFromChain will load ChainID (for signing transactions) and HeadBlockID (to fill transaction with TaPoS data).

type Uint128

type Uint128 struct {
	Lo uint64
	Hi uint64
}

func (Uint128) MarshalJSON

func (i Uint128) MarshalJSON() (data []byte, err error)

func (Uint128) String

func (i Uint128) String() string

func (*Uint128) UnmarshalJSON

func (i *Uint128) UnmarshalJSON(data []byte) error

type Uint64

type Uint64 uint64

func (Uint64) MarshalJSON

func (i Uint64) MarshalJSON() (data []byte, err error)

func (*Uint64) UnmarshalJSON

func (i *Uint64) UnmarshalJSON(data []byte) error

type UnmarshalerBinary

type UnmarshalerBinary interface {
	UnmarshalBinary(decoder *Decoder) error
}

UnmarshalerBinary is the interface implemented by types that can unmarshal an EOSIO binary description of themselves.

**Warning** This is experimental, exposed only for internal usage for now.

type Variant

type Variant interface {
	Assign(typeID uint, impl interface{})
	Obtain() (typeID uint, impl interface{})
}

type VariantDef

type VariantDef struct {
	Name  string   `json:"name"`
	Types []string `json:"types,omitempty"`
}

VariantDef defines a variant type. See libraries/chain/include/eosio/chain/contracts/types.hpp:78

type VariantImplFactory

type VariantImplFactory = func() interface{}

type Varint32

type Varint32 int32

type Varuint32

type Varuint32 uint32

type VoterInfo

type VoterInfo struct {
	Owner             AccountName   `json:"owner"`
	Proxy             AccountName   `json:"proxy"`
	Producers         []AccountName `json:"producers"`
	Staked            Int64         `json:"staked"`
	LastVoteWeight    JSONFloat64   `json:"last_vote_weight"`
	ProxiedVoteWeight JSONFloat64   `json:"proxied_vote_weight"`
	IsProxy           byte          `json:"is_proxy"`
}

type WaitWeight

type WaitWeight struct {
	WaitSec uint32 `json:"wait_sec"`
	Weight  uint16 `json:"weight"` // weight_type
}

type WalletSignTransactionResp

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

type WalletSigner

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

`eosiowd` wallet-based signer

func NewWalletSigner

func NewWalletSigner(api *API, walletName string) *WalletSigner

NewWalletSigner takes an `api`, because often the wallet will be a second endpoint, and not the server node with whom you're pushing transactions to.

func (*WalletSigner) AvailableKeys

func (s *WalletSigner) AvailableKeys() (out []ecc.PublicKey, err error)

func (*WalletSigner) ImportPrivateKey

func (s *WalletSigner) ImportPrivateKey(wifKey string) (err error)

func (*WalletSigner) Sign

func (s *WalletSigner) Sign(tx *SignedTransaction, chainID []byte, requiredKeys ...ecc.PublicKey) (*SignedTransaction, error)

Package Files

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier