neatio

README

Neatio Client

Building the client from source:

To build Neatio client from source you will need to install Go (Golang) and a C compiler.

Note: At least v1.16 of Go is required for building the client.

You can download and install Go from the official guide from the Go website.

After all the dependencies are installed and the $PATH is set, open a terminal and run:

git clone -b main https://github.com/neatio-net/neatio.git
cd neatio
make neatio

Documentation

Index

• Variables
• type CallMsg
• type ChainReader
• type ChainStateReader
• type ChainSyncReader
• type ContractCaller
• type FilterQuery
• type GasEstimator
• type GasPricer
• type LogFilterer
• type PendingContractCaller
• type PendingStateEventer
• type PendingStateReader
• type Subscription
• type SyncProgress
• type TransactionReader
• type TransactionSender

Variables

var NotFound = errors.New("not found")

Types

type CallMsg

type CallMsg struct {
	From     common.Address
	To       *common.Address
	Gas      uint64
	GasPrice *big.Int
	Value    *big.Int
	Data     []byte
}

type ChainReader

type ChainReader interface {
	BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)
	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
	HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)
	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
	TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error)
	TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error)

	SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (Subscription, error)
}

type ChainStateReader

type ChainStateReader interface {
	BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
	StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error)
	CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
}

type ChainSyncReader

type ChainSyncReader interface {
	SyncProgress(ctx context.Context) (*SyncProgress, error)
}

type ContractCaller

type ContractCaller interface {
	CallContract(ctx context.Context, call CallMsg, blockNumber *big.Int) ([]byte, error)
}

type FilterQuery

type FilterQuery struct {
	FromBlock *big.Int
	ToBlock   *big.Int
	Addresses []common.Address

	Topics [][]common.Hash
}

type GasEstimator

type GasEstimator interface {
	EstimateGas(ctx context.Context, call CallMsg) (uint64, error)
}

type GasPricer

type GasPricer interface {
	SuggestGasPrice(ctx context.Context) (*big.Int, error)
}

type LogFilterer

type LogFilterer interface {
	FilterLogs(ctx context.Context, q FilterQuery) ([]types.Log, error)
	SubscribeFilterLogs(ctx context.Context, q FilterQuery, ch chan<- types.Log) (Subscription, error)
}

type PendingContractCaller

type PendingContractCaller interface {
	PendingCallContract(ctx context.Context, call CallMsg) ([]byte, error)
}

type PendingStateEventer

type PendingStateEventer interface {
	SubscribePendingTransactions(ctx context.Context, ch chan<- *types.Transaction) (Subscription, error)
}

type PendingStateReader

type PendingStateReader interface {
	PendingBalanceAt(ctx context.Context, account common.Address) (*big.Int, error)
	PendingStorageAt(ctx context.Context, account common.Address, key common.Hash) ([]byte, error)
	PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
	PendingTransactionCount(ctx context.Context) (uint, error)
}

type Subscription

type Subscription interface {
	Unsubscribe()

	Err() <-chan error
}

type SyncProgress

type SyncProgress struct {
	StartingBlock uint64
	CurrentBlock  uint64
	HighestBlock  uint64
	PulledStates  uint64
	KnownStates   uint64
}

type TransactionReader

type TransactionReader interface {
	TransactionByHash(ctx context.Context, txHash common.Hash) (tx *types.Transaction, isPending bool, err error)

	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
}

type TransactionSender

type TransactionSender interface {
	SendTransaction(ctx context.Context, tx *types.Transaction) error
}