fantom

package
v0.0.0-...-f03d455 Latest Latest
Warning

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

 Go to latest Published: Jun 1, 2022 License: Apache-2.0 Imports: 31 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// NodeVersion is the version of opera we are using.
	NodeVersion = "1.1.0-rc.5"

	// Blockchain is Fantom.
	Blockchain string = "Fantom"

	// TestnetNetwork is the value of the network
	// in NetworkIdentifier.
	TestnetNetwork string = "Testnet"

	// MainnetNetwork is the value of the network
	// in MainnetNetworkIdentifier.
	MainnetNetwork string = "Mainnet"

	// Symbol is the symbol value
	// used in Currency.
	Symbol = "FTM"

	// Decimals is the decimals value
	// used in Currency.
	Decimals = 18

	// FeeOpType is used to represent fee operations.
	FeeOpType = "FEE"

	// CallOpType is used to represent CALL trace operations.
	CallOpType = "CALL"

	// CreateOpType is used to represent CREATE trace operations.
	CreateOpType = "CREATE"

	// Create2OpType is used to represent CREATE2 trace operations.
	Create2OpType = "CREATE2"

	// SelfDestructOpType is used to represent SELFDESTRUCT trace operations.
	SelfDestructOpType = "SELFDESTRUCT"

	// CallCodeOpType is used to represent CALLCODE trace operations.
	CallCodeOpType = "CALLCODE"

	// DelegateCallOpType is used to represent DELEGATECALL trace operations.
	DelegateCallOpType = "DELEGATECALL"

	// StaticCallOpType is used to represent STATICCALL trace operations.
	StaticCallOpType = "STATICCALL"

	// DestructOpType is a synthetic operation used to represent the
	// deletion of suicided accounts that still have funds at the end
	// of a transaction.
	DestructOpType = "DESTRUCT"

	// SuccessStatus is the status of any
	// Opera operation considered successful.
	SuccessStatus = "SUCCESS"

	// FailureStatus is the status of any
	// Opera operation considered unsuccessful.
	FailureStatus = "FAILURE"

	// HistoricalBalanceSupported is whether
	// historical balance is supported.
	HistoricalBalanceSupported = true

	// GenesisBlockIndex is the index of the
	// genesis block.
	GenesisBlockIndex = int64(0)

	// TransferGasLimit is the gas limit
	// of a transfer.
	TransferGasLimit = int64(21000) //nolint:gomnd

	// IncludeMempoolCoins does not apply to rosetta-fantom as it is not UTXO-based.
	IncludeMempoolCoins = false
)

Variables

View Source 
var (
	ErrBlockOrphaned         = errors.New("block orphaned")
	ErrCallParametersInvalid = errors.New("call parameters invalid")
	ErrCallOutputMarshal     = errors.New("call output marshal")
	ErrCallMethodInvalid     = errors.New("call method invalid")
)

Client errors

View Source 
var (
	// FantomMainnetGenesisHash represents the hash of the genesis block (block 0)
	FantomMainnetGenesisHash = common.HexToHash("0x00000000000003e83fddf1e9330f0a8691d9f0b2af57b38c3bb85488488a40df")

	// FantomTestnetGenesisHash represents the hash of the genesis block (block 0)
	FantomTestnetGenesisHash = common.HexToHash("0x00000000000003e8c717f00dc4306a6ff72eabc9a6ec6e4a46bf6ba044ca88d2")
)
View Source 
var (
	// FantomMainnetGenesisBlockIdentifier is the *types.BlockIdentifier
	// of the mainnet genesis block.
	FantomMainnetGenesisBlockIdentifier = &types.BlockIdentifier{
		Hash:  FantomMainnetGenesisHash.Hex(),
		Index: GenesisBlockIndex,
	}

	// FantomTestnetGenesisBlockIdentifier is the *types.BlockIdentifier
	// of the mainnet genesis block.
	FantomTestnetGenesisBlockIdentifier = &types.BlockIdentifier{
		Hash:  FantomTestnetGenesisHash.Hex(),
		Index: GenesisBlockIndex,
	}

	// Currency is the *types.Currency for all
	// Opera networks.
	Currency = &types.Currency{
		Symbol:   Symbol,
		Decimals: Decimals,
	}

	// OperationTypes are all suppoorted operation types.
	OperationTypes = []string{
		FeeOpType,
		CallOpType,
		CreateOpType,
		Create2OpType,
		SelfDestructOpType,
		CallCodeOpType,
		DelegateCallOpType,
		StaticCallOpType,
		DestructOpType,
	}

	// OperationStatuses are all supported operation statuses.
	OperationStatuses = []*types.OperationStatus{
		{
			Status:     SuccessStatus,
			Successful: true,
		},
		{
			Status:     FailureStatus,
			Successful: false,
		},
	}

	// CallMethods are all supported call methods.
	CallMethods = []string{
		"eth_getBlockByNumber",
		"eth_getTransactionReceipt",
		"eth_call",
		"eth_estimateGas",
	}
)

Functions

func CallType 

func CallType(t string) bool

CallType returns a boolean indicating if the provided trace type is a call type.

func ChecksumAddress 

func ChecksumAddress(address string) (string, bool)

ChecksumAddress ensures a hex address is in Checksum Format. If the address cannot be converted, it returns !ok.

func CreateType 

func CreateType(t string) bool

CreateType returns a boolean indicating if the provided trace type is a create type.

func GenerateBootstrapFile 

func GenerateBootstrapFile(genesisFile string, outputFile string) error

GenerateBootstrapFile creates the bootstrap balances file for a particular genesis file.

func MustChecksum 

func MustChecksum(address string) string

MustChecksum ensures an address can be converted into a valid checksum. If it does not, the program will exit.

func StartOpera 

func StartOpera(ctx context.Context, arguments string, g *errgroup.Group) error

StartOpera starts Opera daemon in another goroutine and logs the results to the console.

Types

type Call 

type Call struct {
	Type         string         `json:"type"`
	From         common.Address `json:"from"`
	To           common.Address `json:"to"`
	Value        *big.Int       `json:"value"`
	GasUsed      *big.Int       `json:"gasUsed"`
	Revert       bool
	ErrorMessage string  `json:"error"`
	Calls        []*Call `json:"calls"`
}

Call is an Opera debug trace.

func (*Call) UnmarshalJSON 

func (t *Call) UnmarshalJSON(input []byte) error

UnmarshalJSON is a custom unmarshaler for Call.

type Client 

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

Client allows for querying a set of specific Opera endpoints in an idempotent manner. Client relies on the eth_*, debug_*, admin_*, and txpool_* methods and on the graphql endpoint.

Client borrows HEAVILY from https://github.com/ethereum/go-ethereum/tree/master/ethclient.

func NewClient 

func NewClient(url string, skipAdminCalls bool) (*Client, error)

NewClient creates a Client that from the provided url and params.

func (*Client) Balance 

func (ec *Client) Balance(
	ctx context.Context,
	account *RosettaTypes.AccountIdentifier,
	block *RosettaTypes.PartialBlockIdentifier,
) (*RosettaTypes.AccountBalanceResponse, error)

Balance returns the balance of a *RosettaTypes.AccountIdentifier at a *RosettaTypes.PartialBlockIdentifier.

func (*Client) Block 

func (ec *Client) Block(
	ctx context.Context,
	blockIdentifier *RosettaTypes.PartialBlockIdentifier,
) (*RosettaTypes.Block, error)

Block returns a populated block at the *RosettaTypes.PartialBlockIdentifier. If neither the hash or index is populated in the *RosettaTypes.PartialBlockIdentifier, the current block is returned.

func (*Client) Call 

func (ec *Client) Call(
	ctx context.Context,
	request *RosettaTypes.CallRequest,
) (*RosettaTypes.CallResponse, error)

Call handles calls to the /call endpoint.

func (*Client) Close 

func (ec *Client) Close()

Close shuts down the RPC client connection.

func (*Client) GetMempool 

func (ec *Client) GetMempool(ctx context.Context) (*RosettaTypes.MempoolResponse, error)

GetMempool get and returns all the transactions on Opera TxPool (pending and queued).

func (*Client) PendingNonceAt 

func (ec *Client) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)

PendingNonceAt returns the account nonce of the given account in the pending state. This is the nonce that should be used for the next transaction.

func (*Client) SendTransaction 

func (ec *Client) SendTransaction(ctx context.Context, tx *types.Transaction) error

SendTransaction injects a signed transaction into the pending pool for execution.

If the transaction was a contract creation use the TransactionReceipt method to get the contract address after the transaction has been mined.

func (*Client) Status 

func (ec *Client) Status(ctx context.Context) (
	*RosettaTypes.BlockIdentifier,
	int64,
	*RosettaTypes.SyncStatus,
	[]*RosettaTypes.Peer,
	error,
)

Status returns opera status information for determining node healthiness.

func (*Client) SuggestGasPrice 

func (ec *Client) SuggestGasPrice(ctx context.Context) (*big.Int, error)

SuggestGasPrice retrieves the currently suggested gas price to allow a timely execution of a transaction.

func (*Client) Transaction 

func (ec *Client) Transaction(
	ctx context.Context,
	blockIdentifier *RosettaTypes.BlockIdentifier,
	transactionIdentifier *RosettaTypes.TransactionIdentifier,
) (*RosettaTypes.Transaction, error)

Transaction returns the transaction response of the Transaction identified by *RosettaTypes.TransactionIdentifier hash

type GetBlockByNumberInput 

type GetBlockByNumberInput struct {
	Index         *int64 `json:"index,omitempty"`
	ShowTxDetails bool   `json:"show_transaction_details"`
}

GetBlockByNumberInput is the input to the call method "eth_getBlockByNumber".

type GetCallInput 

type GetCallInput struct {
	BlockIndex int64  `json:"index,omitempty"`
	BlockHash  string `json:"hash,omitempty"`
	From       string `json:"from"`
	To         string `json:"to"`
	Gas        int64  `json:"gas"`
	GasPrice   int64  `json:"gas_price"`
	Value      int64  `json:"value"`
	Data       string `json:"data"`
}

GetCallInput is the input to the call method "eth_call", "eth_estimateGas".

type GetTransactionReceiptInput 

type GetTransactionReceiptInput struct {
	TxHash string `json:"tx_hash"`
}

GetTransactionReceiptInput is the input to the call method "eth_getTransactionReceipt".

type GraphQL 

type GraphQL interface {
	Query(ctx context.Context, input string) (string, error)
}

GraphQL is the interface for accessing go-ethereum's GraphQL endpoint.

type GraphQLClient 

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

GraphQLClient is a client used to make graphQL queries.

func (*GraphQLClient) Query 

func (g *GraphQLClient) Query(ctx context.Context, input string) (string, error)

Query makes a query to the graphQL endpoint.

type JSONRPC 

type JSONRPC interface {
	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
	BatchCallContext(ctx context.Context, b []rpc.BatchElem) error
	Close()
}

JSONRPC is the interface for accessing go-ethereum's JSON RPC endpoint.

Source Files

View all Source files

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.