vex

package module
v0.0.0-...-be87c91 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 23, 2024 License: MIT Imports: 34 Imported by: 0

README

EOS.IO API library for Go

点击查看中文版

GoDoc

This library provides simple access to data structures (binary packing and JSON interface) and API calls to an EOS.IO RPC server, running remotely or locally. It provides wallet functionalities (KeyBag), or can sign transaction through the keosd wallet. It also knows about the P2P protocol on port 9876.

As of before the June launch, this library is pretty much in flux. Don't expect stability, as we're moving alongside the main eosio codebase, which changes very fast.

This library is the basis for the eos-bios launch orchestrator tool at https://genesisblockid/vex-go/eos-bios

Basic usage

package main

import (
	"context"
	"encoding/json"
	"fmt"

	eos "github.com/genesisblockid/vex-go"
	cli "github.com/streamingfast/cli"
)

func main() {
	api := eos.New("https://api.eosn.io")
	ctx := context.Background()

	infoResp, err := api.GetInfo(ctx)
	cli.NoError(err, "unable to get chain info")

	fmt.Println("Chain Info", toJson(infoResp))

	accountResp, _ := api.GetAccount(ctx, "eosio")
	fmt.Println("Account Info", toJson(accountResp))
}

func toJson(v interface{}) string {
	out, err := json.MarshalIndent(v, "", "  ")
	cli.NoError(err, "unable to marshal json")

	return string(out)
}

Examples

Reference
Running

The easiest way to see the actual output for a given example is to add a line // Output: any at the very end of the test, looks like this for ExampleAPI_GetInfo file (examples_api_get_info.go):

	...

    fmt.Println(string(bytes))
    // Output: any
}

This tells go test that it can execute this test correctly. Then, simply run only this example:

go test -run ExampleAPI_GetInfo

Replacing ExampleAPI_GetInfo with the actual example name you want to try out where line // Output: any was added.

This will run the example and compares the standard output with the any which will fail. But it's ok an expected, so you can see the actual output printed to your terminal.

Note Some examples will not succeed out of the box because it requires some configuration. A good example being the transfer operation which requires having the authorizations and balance necessary to perform the transaction. It's quite possible to run them through a development environment however.

Binaries

There is some binaries in main packages under cmd/, mainly around P2P communication.

Environment Variables

All examples uses by default the https://api.eosn.io API endpoint for all HTTP communication and peering.eosn.io for P2P communication. They can respectively be overridden by specifying environment variable EOS_GO_API_URL and EOS_GO_P2P_ENDPOINT respectively.

Tests

Some of our tests renders dates in the timezone of the OS. As such, if you have a bunch of failures around dates and times, it's probably because your timezone is not aligned with those in the tests.

Run the tests with this to be in the same timezone as the expected one in golden files:

TZ=UTC go test ./...

Release

We are using Goreleaser to perform releases. Install the goreleaser binary (instructions) and follow these steps:

  • Dry run release process first with goreleaser release --skip-publish --skip-validate --rm-dist
  • Publish draft release with goreleaser release --rm-dist
  • Open GitHub's release and check that the release is all good
  • Once everything is good, publish release, this will now also push the tag.

Contributing

Any contributions are welcome, use your standard GitHub-fu to pitch in and improve.

License

MIT

Documentation

Index

Examples

Constants

View Source 
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

View Source 
const (
	CompressionNone = CompressionType(iota)
	CompressionZlib
)
View Source 
const JSONTimeFormat = "2006-01-02T15:04:05"
View Source 
const OptionalField optionalFieldType = true

Variables

View Source 
var BlockSigningAuthorityVariant = NewVariantDefinition([]VariantType{
	{"block_signing_authority_v0", (*BlockSigningAuthorityV0)(nil)},
})

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

View Source 
var EOSSymbol = Symbol{Precision: 4, Symbol: "VEX"}

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

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

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

View Source 
var RegisteredActions = map[AccountName]map[ActionName]reflect.Type{}
View Source 
var TNTSymbol = Symbol{Precision: 4, Symbol: "TNT"}

TNTSymbol represents the standard EOSIO Testnet symbol on the testnet chain. Temporary Network Token (TNT) is the native token of the EOSIO Testnet. It's here just to speed up things.

View Source 
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,
}

Functions

func BlockNum 

func BlockNum(blockID string) uint32

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

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 RegisterAction 

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

Registers Action objects..

func SetFloat64MarshalingTypeIntoNumber 

func SetFloat64MarshalingTypeIntoNumber()

func SetFloat64MarshalingTypeIntoString 

func SetFloat64MarshalingTypeIntoString()

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)

Types

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"`
	ActionResults    []ActionResultDef `json:"action_results,omitempty" eos:"binary_extension"`
	// contains filtered or unexported fields
}

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) ActionResultForName 

func (a *ABI) ActionResultForName(name ActionName) *ActionResultDef

func (*ABI) Decode 

func (a *ABI) Decode(binaryDecoder *Decoder, structName string) ([]byte, error)

func (*ABI) DecodeAction 

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

func (*ABI) DecodeActionResult 

func (a *ABI) DecodeActionResult(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 
package main

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

	eos "github.com/genesisblockid/vex-go"
)

func main() {
	abi, err := eos.NewABI(strings.NewReader(abiJSON()))
	if err != nil {
		panic(fmt.Errorf("get ABI: %w", 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: %w", err))
	}

	fmt.Println(string(bytes))
}

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

	return bytes
}

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

Output:

func (*ABI) EncodeAction 

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

func (*ABI) EncodeStruct 

func (a *ABI) EncodeStruct(structName string, json []byte) ([]byte, error)

func (*ABI) EncodeTable 

func (a *ABI) EncodeTable(tableName TableName, json []byte) ([]byte, error)

func (*ABI) SetFitNodeos 

func (a *ABI) SetFitNodeos(v bool)

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(ctx context.Context, code AccountName, action Name, payload HexBytes) (out M, err error)

func (*API) ABIJSONToBin 

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

func (*API) CreateSnapshot 

func (api *API) CreateSnapshot(ctx context.Context) (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(ctx context.Context) 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(ctx context.Context, account AccountName) (out *GetABIResp, err error)

func (*API) GetAccount 

func (api *API) GetAccount(ctx context.Context, name AccountName, opts ...GetAccountOption) (out *AccountResp, err error)
Example 
api := eos.New(getAPIURL())

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

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

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

fmt.Println(string(bytes))

Output:

func (*API) GetAccountsByAuthorizers 

func (api *API) GetAccountsByAuthorizers(ctx context.Context, authorizations []PermissionLevel, keys []ecc.PublicKey) (out *GetAccountsByAuthorizersResp, err error)

func (*API) GetActions 

func (api *API) GetActions(ctx context.Context, params GetActionsRequest) (out *ActionsResp, err error)

func (*API) GetBlockByID 

func (api *API) GetBlockByID(ctx context.Context, id string) (out *BlockResp, err error)

func (*API) GetBlockByNum 

func (api *API) GetBlockByNum(ctx context.Context, num uint32) (out *BlockResp, err error)

func (*API) GetBlockByNumOrID 

func (api *API) GetBlockByNumOrID(ctx context.Context, query string) (out *SignedBlock, err error)

func (*API) GetBlockByNumOrIDRaw 

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

func (*API) GetCode 

func (api *API) GetCode(ctx context.Context, account AccountName) (out *GetCodeResp, err error)

func (*API) GetCodeHash 

func (api *API) GetCodeHash(ctx context.Context, account AccountName) (out Checksum256, err error)

func (*API) GetControlledAccounts 

func (api *API) GetControlledAccounts(ctx context.Context, controllingAccount string) (out *ControlledAccountsResp, err error)

func (*API) GetCurrencyBalance 

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

func (*API) GetCurrencyStats 

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

func (*API) GetDBSize 

func (api *API) GetDBSize(ctx context.Context) (out *DBSizeResp, err error)

func (*API) GetInfo 

func (api *API) GetInfo(ctx context.Context) (out *InfoResp, err error)
Example 
api := eos.New(getAPIURL())

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

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

fmt.Println(string(bytes))

Output:

func (*API) GetIntegrityHash 

func (api *API) GetIntegrityHash(ctx context.Context) (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(ctx context.Context, publicKey string) (out *KeyAccountsResp, err error)

func (*API) GetNetConnections 

func (api *API) GetNetConnections(ctx context.Context) (out []*NetConnectionsResp, err error)

func (*API) GetNetStatus 

func (api *API) GetNetStatus(ctx context.Context, host string) (out *NetStatusResp, err error)

func (*API) GetProducerProtocolFeatures 

func (api *API) GetProducerProtocolFeatures(ctx context.Context) (out []ProtocolFeature, err error)

func (*API) GetProducers 

func (api *API) GetProducers(ctx context.Context) (out *ProducersResp, err error)
Example 
api := eos.New(getAPIURL())

resp, err := api.GetProducers(context.Background())
if err != nil {
	panic(fmt.Errorf("get account: %w", err))
}

sort.Slice(resp.Producers, func(i, j int) bool {
	if resp.Producers[i].IsActive && !resp.Producers[j].IsActive {
		return true
	}

	return resp.Producers[i].TotalVotes < resp.Producers[j].TotalVotes
})

for _, producer := range resp.Producers {
	fmt.Printf("Producer %s (%s) with %.5f votes (last claimed %s)\n", producer.Owner, producer.URL, producer.TotalVotes, producer.LastClaimTime)
}

fmt.Printf("Total Vote Weight: %.4f\n", resp.TotalProducerVoteWeight)
fmt.Printf("More: %s\n", resp.More)

Output:

func (*API) GetPublicKeys 

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

func (*API) GetRawABI 

func (api *API) GetRawABI(ctx context.Context, params GetRawABIRequest) (out *GetRawABIResp, err error)

func (*API) GetRawCodeAndABI 

func (api *API) GetRawCodeAndABI(ctx context.Context, account AccountName) (out *GetRawCodeAndABIResp, err error)

func (*API) GetRequiredKeys 

func (api *API) GetRequiredKeys(ctx context.Context, tx *Transaction) (out *GetRequiredKeysResp, err error)

func (*API) GetScheduledTransactions 

func (api *API) GetScheduledTransactions(ctx context.Context) (out *ScheduledTransactionsResp, err error)

GetScheduledTransactions returns the Top 100 scheduled transactions

func (*API) GetScheduledTransactionsWithBounds 

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

GetScheduledTransactionsWithBounds returns scheduled transactions within specified bounds

func (*API) GetTableByScope 

func (api *API) GetTableByScope(ctx context.Context, params GetTableByScopeRequest) (out *GetTableByScopeResp, err error)

func (*API) GetTableRows 

func (api *API) GetTableRows(ctx context.Context, params GetTableRowsRequest) (out *GetTableRowsResp, err error)

func (*API) GetTransaction 

func (api *API) GetTransaction(ctx context.Context, id string) (out *TransactionResp, err error)

func (*API) GetTransactionRaw 

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

func (*API) GetTransactions 

func (api *API) GetTransactions(ctx context.Context, name AccountName) (out *TransactionsResp, err error)

func (*API) IsProducerPaused 

func (api *API) IsProducerPaused(ctx context.Context) (out bool, err error)

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

func (*API) ListKeys 

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

func (*API) ListWallets 

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

func (*API) NetConnect 

func (api *API) NetConnect(ctx context.Context, host string) (out NetConnectResp, err error)

func (*API) NetDisconnect 

func (api *API) NetDisconnect(ctx context.Context, host string) (out NetDisconnectResp, err error)

func (*API) ProducerPause 

func (api *API) ProducerPause(ctx context.Context) error

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

func (*API) ProducerResume 

func (api *API) ProducerResume(ctx context.Context) 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(ctx context.Context, tx *PackedTransaction) (out *PushTransactionFullResp, err error)

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

Example (Transfer_EOS) 
package main

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

	eos "github.com/genesisblockid/vex-go"
	"github.com/genesisblockid/vex-go/token"
)

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

	keyBag := &eos.KeyBag{}
	err := keyBag.ImportPrivateKey(context.Background(), readPrivateKey())
	if err != nil {
		panic(fmt.Errorf("import private key: %w", 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: %w", err))
	}

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

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

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

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

	response, err := api.PushTransaction(context.Background(), packedTx)
	if err != nil {
		panic(fmt.Errorf("push transaction: %w", 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
}

Output:

func (*API) PushTransactionRaw 

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

func (*API) ScheduleProducerProtocolFeatureActivations 

func (api *API) ScheduleProducerProtocolFeatureActivations(ctx context.Context, protocolFeaturesToActivate []Checksum256) error

func (*API) SendTransaction 

func (api *API) SendTransaction(ctx context.Context, tx *PackedTransaction) (out *PushTransactionFullResp, err error)

func (*API) SendTransactionRaw 

func (api *API) SendTransactionRaw(ctx context.Context, tx *PackedTransaction) (out json.RawMessage, err error)

func (*API) SetCustomGetRequiredKeys 

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

func (*API) SetSigner 

func (api *API) SetSigner(s Signer)

func (*API) SignPushActions 

func (api *API) SignPushActions(ctx context.Context, 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(ctx context.Context, actions []*Action, opts *TxOptions) (out *PushTransactionFullResp, err error)

func (*API) SignPushTransaction 

func (api *API) SignPushTransaction(ctx context.Context, 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(ctx context.Context, 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) UsePartialRequiredKeys 

func (api *API) UsePartialRequiredKeys()

func (*API) WalletCreate 

func (api *API) WalletCreate(ctx context.Context, walletName string) (err error)

func (*API) WalletImportKey 

func (api *API) WalletImportKey(ctx context.Context, walletName, wifPrivKey string) (err error)

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

func (*API) WalletLock 

func (api *API) WalletLock(ctx context.Context, walletName string) (err error)

func (*API) WalletLockAll 

func (api *API) WalletLockAll(ctx context.Context) (err error)

func (*API) WalletOpen 

func (api *API) WalletOpen(ctx context.Context, walletName string) (err error)

func (*API) WalletPublicKeys 

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

func (*API) WalletSetTimeout 

func (api *API) WalletSetTimeout(ctx context.Context, timeout int32) (err error)

func (*API) WalletSignTransaction 

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

func (*API) WalletUnlock 

func (api *API) WalletUnlock(ctx context.Context, 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 vexerr.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 AccountDelta 

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

type AccountName 

type AccountName Name

func AN 

func AN(in string) AccountName

func (AccountName) String 

func (n AccountName) String() string

type AccountRAMDelta deprecated 

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

AccountRAMDelta

Deprecated: Use AccountDelta instead which is the struct name used in EOSIO

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         BlockTimestamp       `json:"last_code_update"` // modified since EOSIO/Leap v2.0 YYYY-MM-DDTHH:MM:SS -> YYYY-MM-DDTHH:MM:SS.sss
	Created                BlockTimestamp       `json:"created"`          // modified since EOSIO/Leap v2.0 YYYY-MM-DDTHH:MM:SS -> YYYY-MM-DDTHH:MM:SS.sss
	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"`
	HeadBlockNum           uint64               `json:"head_block_num"`            // added since EOSIO/Leap v2.0
	HeadBlockTime          BlockTimestamp       `json:"head_block_time"`           // added since EOSIO/Leap v2.0
	RexInfo                *RexInfo             `json:"rex_info,omitempty"`        // added since EOSIO/Leap v2.0
	SubjectiveSpuBillLimit AccountResourceLimit `json:"subjective_cpu_bill_limit"` // added since EOSIO/Leap v2.0
	EosioAnyLinkedActions  []LinkedAction       `json:"eosio_any_linked_actions"`  // added since EOSIO/Leap v2.0
}

type AccountResult 

type AccountResult struct {
	Account            AccountName      `json:"account_name"`
	Permission         PermissionName   `json:"permission_name"`
	AuthorizingAccount *PermissionLevel `json:"authorizing_account,omitempty"`
	AuthorizingKey     *ecc.PublicKey   `json:"authorizing_key,omitempty"`
	Weight             uint16           `json:"weight"`
	Threshold          uint32           `json:"threshold"`
}

TODO: what's the name of the struct

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

func (ActionName) String 

func (n ActionName) String() string

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"`
	Irreversible bool           `json:"irreversible"`
}

type ActionResultDef 

type ActionResultDef struct {
	Name       ActionName `json:"name"`
	ResultType string     `json:"result_type"`
}

type ActionTrace 

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

	// Not present in EOSIO >= 1.8.x
	InlineTraces []ActionTrace `json:"inline_traces,omitempty" eos:"-"`
}

type ActionTraceReceipt 

type ActionTraceReceipt struct {
	Receiver        AccountName                    `json:"receiver"`
	ActionDigest    Checksum256                    `json:"act_digest"`
	GlobalSequence  Uint64                         `json:"global_sequence"`
	ReceiveSequence Uint64                         `json:"recv_sequence"`
	AuthSequence    []TransactionTraceAuthSequence `json:"auth_sequence"` // [["account", sequence], ["account", sequence]]
	CodeSequence    Varuint32                      `json:"code_sequence"`
	ABISequence     Varuint32                      `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 deprecated 

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 and decodes it to an eos.Asset structure if possible. The input must contain an amount and a symbol, unless an empty asset is given in the form of "0". 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 NewTNTAssetFromString 

func NewTNTAssetFromString(input string) (Asset, error)

func (Asset) Add 

func (a Asset) Add(other Asset) Asset

func (*Asset) IsZero 

func (a *Asset) IsZero() bool

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 uint32
	Impl   interface{}
}

func (*BaseVariant) Assign 

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

func (*BaseVariant) MarshalJSON 

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

func (*BaseVariant) Obtain 

func (a *BaseVariant) Obtain(def *VariantDefinition) (typeID uint32, typeName string, impl interface{})

func (*BaseVariant) UnmarshalBinaryVariant 

func (a *BaseVariant) UnmarshalBinaryVariant(decoder *Decoder, def *VariantDefinition) error

func (*BaseVariant) UnmarshalJSON 

func (a *BaseVariant) UnmarshalJSON(data []byte, def *VariantDefinition) 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
}

func (*BlockSigningAuthority) MarshalJSON 

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

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   []PairAccountNameBlockNum `json:"producer_to_last_produced,omitempty"`
	ProducerToLastImpliedIRB []PairAccountNameBlockNum `json:"producer_to_last_implied_irb,omitempty"`

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

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

	BlockID                   Checksum256                   `json:"id"`
	Header                    *SignedBlockHeader            `json:"header,omitempty"`
	PendingSchedule           *PendingSchedule              `json:"pending_schedule"`
	ActivatedProtocolFeatures *ProtocolFeatureActivationSet `json:"activated_protocol_features,omitempty" eos:"optional"`
	AdditionalSignatures      []ecc.Signature               `json:"additional_signatures"`

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

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

FIXME: This structure supports both EOS 1.8.x as well as EOS 2.0.x. However, the binary encoding 

format does only support the 2.0.x version for now. It's not clear how we would do thing
to propagate the information that encoding/decoding of binary should be performed with one
variant or the other. When this comment was added, the binary encoding/decoding was not
working for either version, so supporting EOS 2.0.x only is a fair improvements. Will need
to understand better if this is required for other chains for example.

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) LastPos 

func (d *Decoder) LastPos() int

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) ReadInt128 

func (d *Decoder) ReadInt128() (out Int128, 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) ReadNodeosFloat32 

func (d *Decoder) ReadNodeosFloat32() (out float32, 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 deprecated 

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)

func (*Decoder) SafeReadUTF8String 

func (d *Decoder) SafeReadUTF8String() (out string, 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 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    Int64               `json:"code"`
	Name    string              `json:"name"`
	Message string              `json:"message"`
	Stack   []*ExceptLogMessage `json:"stack"`
}

type ExceptLogContext 

type ExceptLogContext struct {
	Level      ExceptLogLevel    `json:"level"`
	File       string            `json:"file"`
	Line       uint64            `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 ExceptLogLevel 

type ExceptLogLevel uint8
const (
	ExceptLogLevelAll ExceptLogLevel = iota
	ExceptLogLevelDebug
	ExceptLogLevelInfo
	ExceptLogLevelWarn
	ExceptLogLevelError
	ExceptLogLevelOff
)

func (*ExceptLogLevel) FromString 

func (s *ExceptLogLevel) FromString(input string)

func (ExceptLogLevel) MarshalJSON 

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

func (ExceptLogLevel) String 

func (s ExceptLogLevel) String() string

func (*ExceptLogLevel) UnmarshalJSON 

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

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.

func (*ExceptLogMessage) UnmarshalBinary 

func (m *ExceptLogMessage) UnmarshalBinary(decoder *Decoder) error

type ExtendedAsset 

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

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) UnmarshalBinary 

func (e *Extension) UnmarshalBinary(decoder *Decoder) 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 Float64 

type Float64 float64

func (*Float64) MarshalJSON 

func (f *Float64) MarshalJSON() ([]byte, error)

func (*Float64) UnmarshalJSON 

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

type GetABIResp 

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

type GetAccountOption 

type GetAccountOption interface {
	// contains filtered or unexported methods
}

func WithCoreSymbol 

func WithCoreSymbol(symbol Symbol) GetAccountOption

type GetAccountsByAuthorizersResp 

type GetAccountsByAuthorizersResp struct {
	Accounts []AccountResult `json:"accounts"`
}

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 string          `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
	Reverse    bool   `json:"reverse,omitempty"`        // Get rows in reverse of the index
	JSON       bool   `json:"json"`                     // JSON expectOutput 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"
	EarliestAvailableBlockNum uint64         `json:"earliest_available_block_num"` // added since EOSIO/Leap v2.0
	ForkDbHeadBlockNum        uint64         `json:"fork_db_head_block_num"`       // added since EOSIO/Leap v2.0
	ForkDbHeadBlockId         string         `json:"fork_db_head_block_id"`        // added since EOSIO/Leap v2.0
	LastIrreversibleBlockTime BlockTimestamp `json:"last_irreversible_block_time"` // added since EOSIO/Leap v2.0

	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"`
	TotalCpuWeight          Int64  `json:"total_cpu_weight"` // added since EOSIO/Leap v2.0
	TotalNetWeight          Int64  `json:"total_net_weight"` // added since EOSIO/Leap v2.0
	ServerVersionString     string `json:"server_version_string"`
	ServerFullVersionString string `json:"server_full_version_string"` // added since EOSIO/Leap v2.0
}

type Int128 

type Int128 Uint128

Int128

func (Int128) BigInt 

func (i Int128) BigInt() *big.Int

func (Int128) DecimalString 

func (i Int128) DecimalString() string

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

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) Append 

func (b *KeyBag) Append(privateKey *ecc.PrivateKey) error

func (*KeyBag) AvailableKeys 

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

func (*KeyBag) ImportFromFile 

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

func (*KeyBag) ImportPrivateKey 

func (b *KeyBag) ImportPrivateKey(ctx context.Context, wifPrivKey string) (err error)

func (*KeyBag) Sign 

func (b *KeyBag) Sign(ctx context.Context, 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 LinkedAction 

type LinkedAction struct {
	Account AccountName `json:"account"`
	Action  ActionName  `json:"action,omitempty"`
}

SimpleAction was added since EOSIO/Leap v2.0 chain_plugin/chain_plugin.hpp::eosio::chain_apis::linked_action

type M 

type M map[string]interface{}

type MarshalerBinary 

type MarshalerBinary interface {
	MarshalBinary(encoder *Encoder) error
}

MarshalerBinary is the interface implemented by types that can marshal to an VEXCORE binary description of themselves.

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

type MerkleRoot 

type MerkleRoot struct {
	ActiveNodes []Checksum256 `json:"_active_nodes"`
	NodeCount   uint64        `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

func (Name) String 

func (n Name) String() 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"`
	ContextFreeData       []string        `json:"context_free_data,omitempty" eos:"-"`
	Transaction           *Transaction    `json:"transaction,omitempty" eos:"-"`
	// 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 
package main

import (
	"encoding/json"
	"fmt"

	eos "github.com/genesisblockid/vex-go"
)

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

	var signedTrx *eos.SignedTransaction
	signedTrx, err = packedTrx.Unpack()
	if err != nil {
		panic(fmt.Errorf("unpacking transaction: %w", 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"
	  }
	`)
}

Output:

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 PairAccountNameBlockNum 

type PairAccountNameBlockNum struct {
	AccountName AccountName
	BlockNum    uint32
}

func (PairAccountNameBlockNum) MarshalJSON 

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

func (*PairAccountNameBlockNum) UnmarshalBinary 

func (c *PairAccountNameBlockNum) UnmarshalBinary(decoder *Decoder) error

func (*PairAccountNameBlockNum) UnmarshalJSON 

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

type PendingSchedule 

type PendingSchedule struct {
	ScheduleLIBNum uint32                               `json:"schedule_lib_num"`
	ScheduleHash   Checksum256                          `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"`
	LinkedActions []LinkedAction `json:"linked_actions"` // added since EOSIO/Leap v2.0, TODO: find the better type from the current implementation
}

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.

func (PermissionLevel) String 

func (p PermissionLevel) String() string

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

func (PermissionName) String 

func (n PermissionName) String() string

type ProcessedTransaction 

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

type Producer 

type Producer struct {
	Owner         Name          `json:"owner"`
	TotalVotes    Float64       `json:"total_votes,string"`
	ProducerKey   ecc.PublicKey `json:"producer_key"`
	IsActive      Bool          `json:"is_active"`
	URL           string        `json:"url"`
	UnpaidBlocks  int           `json:"unpaid_blocks"`
	LastClaimTime JSONTime      `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) UnmarshalBinary 

func (p *ProducerScheduleOrAuthoritySchedule) UnmarshalBinary(decoder *Decoder) error

func (*ProducerScheduleOrAuthoritySchedule) UnmarshalJSON 

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

type ProducersResp 

type ProducersResp struct {
	Producers               []Producer `json:"rows"`
	TotalProducerVoteWeight Float64    `json:"total_producer_vote_weight"`
	More                    Name       `json:"more"`
}

type ProtocolFeature 

type ProtocolFeature struct {
	FeatureDigest         Checksum256                    `json:"feature_digest"`
	SubjectiveRestriction SubjectiveRestriction          `json:"subjective_restrictions"`
	DescriptionDigest     Checksum256                    `json:"description_digest"`
	Dependencies          []Checksum256                  `json:"dependencies"`
	ProtocolFeatureType   string                         `json:"protocol_feature_type"`
	Specification         []ProtocolFeatureSpecification `json:"specification"`
}

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 ProtocolFeatureActivationSet 

type ProtocolFeatureActivationSet struct {
	ProtocolFeatures []Checksum256 `json:"protocol_features"`
}

type ProtocolFeatureSpecification 

type ProtocolFeatureSpecification struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

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

PushTransactionFullResp unwraps the responses from a successful `push_transaction`. FIXME: REVIEW the actual expectOutput, 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 RexInfo 

type RexInfo struct {
	Version    uint32      `json:"version"`
	Owner      AccountName `json:"owner"`
	VoteStake  Asset       `json:"vote_stake"`
	RexBalance Asset       `json:"rex_balance"`
	MaturedRex uint64      `json:"matured_rex"`

	// TODO: set the exact type
	RexMaturities []interface{} `json:"rex_maturities"`
}

RexInfo was added since EOSIO/Leap v2.0

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 SafeString 

type SafeString string

func (*SafeString) UnmarshalBinary 

func (ss *SafeString) UnmarshalBinary(d *Decoder) error

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

func (ScopeName) String 

func (n ScopeName) String() string

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(ctx context.Context) (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(ctx context.Context, tx *SignedTransaction, chainID []byte, requiredKeys ...ecc.PublicKey) (*SignedTransaction, error)

	ImportPrivateKey(ctx context.Context, wifPrivKey string) error
}

type StructDef 

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

type SubjectiveRestriction 

type SubjectiveRestriction struct {
	Enabled                       bool     `json:"enabled"`
	PreactivationRequired         bool     `json:"preactivation_required"`
	EarliestAllowedActivationTime JSONTime `json:"earliest_allowed_activation_time"`
}

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) IsZero 

func (s Symbol) IsZero() bool

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)

func (*Symbol) UnmarshalJSON 

func (s *Symbol) UnmarshalJSON(data []byte) 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

func (TableName) String 

func (n TableName) String() string

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)

func (TimePoint) AsTime 

func (f TimePoint) AsTime() time.Time

AsTime returns the TimePoint as time.Time in UTC

func (TimePoint) MarshalJSON 

func (f TimePoint) MarshalJSON() ([]byte, error)

func (TimePoint) String 

func (f TimePoint) String() string

func (*TimePoint) UnmarshalJSON 

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

type TimePointSec 

type TimePointSec uint32

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

func (TimePointSec) AsTime 

func (f TimePointSec) AsTime() time.Time

AsTime returns the TimePointSec as time.Time in UTC

func (TimePointSec) MarshalJSON 

func (f TimePointSec) MarshalJSON() ([]byte, error)

func (TimePointSec) String 

func (f TimePointSec) String() string

func (*TimePointSec) UnmarshalJSON 

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

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

Transaction represents an EOS transaction that is no signed yet.

**Note** In EOSIO codebase, used within both `signed_transaction` and `transaction`.

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"`
	BlockNum             uint32      `json:"block_num"`
	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" eos:"optional"`
	Receipt         *TransactionReceiptHeader `json:"receipt,omitempty" eos:"optional"`
	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" eos:"optional"`
	FailedDtrxTrace *TransactionTrace `json:"failed_dtrx_trace,omitempty" eos:"optional"`
	Except          *Except           `json:"except,omitempty" eos:"optional"`
	ErrorCode       *Uint64           `json:"error_code,omitempty" eos:"optional"`
}

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(ctx context.Context, 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
}

uint128

func (Uint128) BigInt 

func (i Uint128) BigInt() *big.Int

func (Uint128) DecimalString 

func (i Uint128) DecimalString() string

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) MarshalBinary 

func (i Uint64) MarshalBinary(encoder *Encoder) error

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 vexcore 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 VariantDefinition 

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

func NewVariantDefinition 

func NewVariantDefinition(types []VariantType) (out *VariantDefinition)

NewVariantDefinition creates a variant definition based on the *ordered* provided types. It's the ordering that defines the binary variant value just like in native `nodeos` C++ and in Smart Contract via the `std::variant` type. It's important to pass the entries in the right order!

This variant definition can now be passed to functions of `BaseVariant` to implement marshal/unmarshaling functionalities for binary & JSON.

func (*VariantDefinition) TypeID 

func (d *VariantDefinition) TypeID(name string) uint32

type VariantImplFactory 

type VariantImplFactory = func() interface{}

type VariantType 

type VariantType struct {
	Name string
	Type 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    Float64       `json:"last_vote_weight"`
	ProxiedVoteWeight Float64       `json:"proxied_vote_weight"`
	IsProxy           byte          `json:"is_proxy"`
	Flags1            int64         `json:"flags1"`    // added since EOSIO/Leap v2.0
	Reserved2         int64         `json:"reserved2"` // added since EOSIO/Leap v2.0
	Reserved3         Asset         `json:"reserved3"` // added since EOSIO/Leap v2.0
}

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(ctx context.Context) (out []ecc.PublicKey, err error)

func (*WalletSigner) ImportPrivateKey 

func (s *WalletSigner) ImportPrivateKey(ctx context.Context, wifKey string) (err error)

func (*WalletSigner) Sign 

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

Source Files

View all Source files

Directories

Path Synopsis
btcsuite
btcd/btcec
Package btcec implements support for the elliptic curves needed for bitcoin.
 Package btcec implements support for the elliptic curves needed for bitcoin.
btcutil
Package btcutil provides bitcoin-specific convenience functions and types.
 Package btcutil provides bitcoin-specific convenience functions and types.
btcutil/base58
Package base58 provides an API for working with modified base58 and Base58Check encodings.
 Package base58 provides an API for working with modified base58 and Base58Check encodings.
cmd
eos-hexpubkey
eos-p2p-client
eos-p2p-proxy
eos-p2p-relay
eos-print-tx

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.