evm

package
v0.1.8 Latest Latest
Warning

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

Go to latest
Published: Jul 31, 2023 License: Apache-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source
const ERC165GasLimit uint64 = 30_000
View Source
const EVMModuleName = "evm"

TODO: can we move this to oasis-sdk/client-sdk/go/modules/evm?

View Source
const NativeRuntimeTokenAddress = "oasis1runt1menat1vet0ken0000000000000000000000"

A fake address that is used to represent the native runtime token in contexts that are primarily intended for tracking EVM tokens (= contract-based tokens).

Variables

View Source
var (
	// https://github.com/oasisprotocol/oasis-web3-gateway/blob/v3.0.0/rpc/eth/api.go#L403-L408
	DefaultGasPrice        = []byte{1}
	DefaultGasLimit uint64 = 30_000_000
	DefaultCaller          = ethCommon.Address{1}.Bytes()
	DefaultValue           = []byte{0}
)
View Source
var (
	InvalidInterfaceID             = []byte{0xff, 0xff, 0xff, 0xff}
	ERC165InterfaceID              = InterfaceID(evmabi.ERC165)
	ERC721InterfaceID              = InterfaceID(evmabi.ERC721)
	ERC721TokenReceiverInterfaceID = InterfaceID(evmabi.ERC721TokenReceiver)
	ERC721MetadataInterfaceID      = InterfaceID(evmabi.ERC721Metadata)
	ERC721EnumerableInterfaceID    = InterfaceID(evmabi.ERC721Enumerable)
)

Functions

func InterfaceID

func InterfaceID(abi *abi.ABI) []byte

Types

type EVMContractData

type EVMContractData struct {
	Address          apiTypes.Address
	CreationBytecode []byte
	CreationTx       string
}

type EVMDeterministicError

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

func (EVMDeterministicError) Is

func (err EVMDeterministicError) Is(target error) bool

type EVMEncryptedData

type EVMEncryptedData struct {
	Format      common.CallFormat
	PublicKey   []byte
	DataNonce   []byte
	DataData    []byte
	ResultNonce []byte
	ResultData  []byte
}

func EVMMaybeUnmarshalEncryptedData

func EVMMaybeUnmarshalEncryptedData(data []byte, result *[]byte) (*EVMEncryptedData, error)

EVMMaybeUnmarshalEncryptedData breaks down a possibly encrypted data + result into their encryption envelope fields. If the data is not encrypted, it returns nil with no error.

type EVMPossibleToken

type EVMPossibleToken struct {
	Mutated           bool
	TotalSupplyChange *big.Int
}

type EVMTokenBalanceData

type EVMTokenBalanceData struct {
	// Balance... if you're here to ask about why there's a "balance" struct
	// with a Balance field, it's because the struct is really a little
	// document that the EVMDownloadTokenBalance function can optionally give
	// you about an account. (And we didn't name the struct "account" because
	// the only thing inside it is the balance.) We let that function return a
	// *EVMTokenBalanceData so that it can return nil if it can determine that
	// the contract is not supported. Plus, Go's idea of an arbitrary size
	// integer is *big.Int, and we don't want anyone fainting if they see a
	// ** in the codebase.
	Balance *big.Int
}

func EVMDownloadTokenBalance

func EVMDownloadTokenBalance(ctx context.Context, logger *log.Logger, source nodeapi.RuntimeApiLite, round uint64, tokenEthAddr []byte, accountEthAddr []byte, tokenType EVMTokenType) (*EVMTokenBalanceData, error)

EVMDownloadTokenBalance tries to download the balance of a given account for a given token. If it transiently fails to download the balance, it returns with a non-nil error. If it deterministically cannot download the balance, it returns nil with nil error as well. Note that this latter case is not considered an error!

type EVMTokenData

type EVMTokenData struct {
	Type     EVMTokenType
	Name     string
	Symbol   string
	Decimals uint8
	*EVMTokenMutableData
}

func EVMDownloadNewToken

func EVMDownloadNewToken(ctx context.Context, logger *log.Logger, source nodeapi.RuntimeApiLite, round uint64, tokenEthAddr []byte) (*EVMTokenData, error)

EVMDownloadNewToken tries to download the data of a given token. If it transiently fails to download the data, it returns with a non-nil error. If it deterministically cannot download the data, it returns a struct with the `Type` field set to `EVMTokenTypeUnsupported`.

type EVMTokenMutableData

type EVMTokenMutableData struct {
	TotalSupply *big.Int
}

func EVMDownloadMutatedToken

func EVMDownloadMutatedToken(ctx context.Context, logger *log.Logger, source nodeapi.RuntimeApiLite, round uint64, tokenEthAddr []byte, tokenType EVMTokenType) (*EVMTokenMutableData, error)

EVMDownloadMutatedToken tries to download the mutable data of a given token. If it transiently fails to download the data, it returns with a non-nil error. If it deterministically cannot download the data, it returns nil with nil error as well. Note that this latter case is not considered an error!

type EVMTokenType

type EVMTokenType int

EVMTokenType is a small-ish number that we use to identify what type of token each row of the tokens table is. Values aren't consecutive like in an enum. Prefer to use the number of the ERC if applicable and available, e.g. 20 for ERC-20. "Historical reasons" style note: this has grown to include non-EVM token types as well.

const (
	EVMTokenTypeNative      EVMTokenType = -1 // A placeholder type to represent the runtime's native token. No contract should be assigned this type.
	EVMTokenTypeUnsupported EVMTokenType = 0  // A smart contract for which we're confident it's not a supported token kind.
)
const EVMTokenTypeERC20 EVMTokenType = 20
const EVMTokenTypeERC721 EVMTokenType = 721

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL