Documentation

Index

Constants

View Source
const (
	DataStackInitialCapacity    = 1024
	MaximumAllowedBlockLookBack = 256
)

Variables

This section is empty.

Functions

func Is64BitOverflow

func Is64BitOverflow(word Word256) bool

Types

type Code

type Code struct {
	Bytecode     acm.Bytecode
	OpcodeBitset bitset.Bitset
}

func NewCode

func NewCode(code []byte) *Code

    Build a Code object that includes analysis of which symbols are opcodes versus push data

    func (*Code) GetBytecode

    func (code *Code) GetBytecode() acm.Bytecode

    func (*Code) GetSymbol

    func (code *Code) GetSymbol(n uint64) asm.OpCode

    func (*Code) IsOpcode

    func (code *Code) IsOpcode(indexOfSymbolInCode uint64) bool

    func (*Code) IsPushData

    func (code *Code) IsPushData(indexOfSymbolInCode uint64) bool

    func (*Code) Length

    func (code *Code) Length() uint64

    type Contract

    type Contract struct {
    	*EVM
    	*Code
    }

    func (*Contract) Call

    func (c *Contract) Call(state engine.State, params engine.CallParams) ([]byte, error)

    type EVM

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

    func Default

    func Default() *EVM

    func New

    func New(options Options) *EVM

    func (*EVM) Contract

    func (vm *EVM) Contract(code []byte) *Contract

    func (*EVM) Dispatch

    func (vm *EVM) Dispatch(acc *acm.Account) engine.Callable

    func (*EVM) Execute

    func (vm *EVM) Execute(st acmstate.ReaderWriter, blockchain engine.Blockchain, eventSink exec.EventSink,
    	params engine.CallParams, code []byte) ([]byte, error)

      Initiate an EVM call against the provided state pushing events to eventSink. code should contain the EVM bytecode, input the CallData (readable by CALLDATALOAD), value the amount of native token to transfer with the call an quantity metering the number of computational steps available to the execution according to the gas schedule.

      func (*EVM) SetExternals

      func (vm *EVM) SetExternals(externals engine.Dispatcher)

      func (*EVM) SetLogger

      func (vm *EVM) SetLogger(logger *logging.Logger)

      func (*EVM) SetNonce

      func (vm *EVM) SetNonce(nonce []byte)

        Sets a new nonce and resets the sequence number. Nonces should only be used once! A global counter or sufficient randomness will work.

        type Memory

        type Memory interface {
        	// Read a value from the memory store starting at offset
        	// (index of first byte will equal offset). The value will be returned as a
        	// length-bytes byte slice. Returns an error if the memory cannot be read or
        	// is not allocated.
        	//
        	// The value returned should be copy of any underlying memory, not a reference
        	// to the underlying store.
        	Read(offset, length *big.Int) []byte
        	// Write a value to the memory starting at offset (the index of the first byte
        	// written will equal offset). The value is provided as bytes to be written
        	// consecutively to the memory store. Return an error if the memory cannot be
        	// written or allocated.
        	Write(offset *big.Int, value []byte)
        	// Returns the current capacity of the memory. For dynamically allocating
        	// memory this capacity can be used as a write offset that is guaranteed to be
        	// unused. Solidity in particular makes this assumption when using MSIZE to
        	// get the current allocated memory.
        	Capacity() *big.Int
        }

          Interface for a bounded linear memory indexed by a single *big.Int parameter for each byte in the memory.

          func DefaultDynamicMemoryProvider

          func DefaultDynamicMemoryProvider(errSink errors.Sink) Memory

          func NewDynamicMemory

          func NewDynamicMemory(initialCapacity, maximumCapacity uint64, errSink errors.Sink) Memory

            Get a new DynamicMemory (note that although we take a maximumCapacity of uint64 we currently limit the maximum to int32 at runtime because we are using a single slice which we cannot guarantee to be indexable above int32 or all validators

            type Options

            type Options struct {
            	MemoryProvider           func(errors.Sink) Memory
            	Natives                  *native.Natives
            	Nonce                    []byte
            	DebugOpcodes             bool
            	DumpTokens               bool
            	CallStackMaxDepth        uint64
            	DataStackInitialCapacity uint64
            	DataStackMaxDepth        uint64
            	Logger                   *logging.Logger
            }

              Options are parameters that are generally stable across a burrow configuration. Defaults will be used for any zero values.

              type Stack

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

                Not goroutine safe

                func NewStack

                func NewStack(errSink errors.Sink, initialCapacity uint64, maxCapacity uint64, gas *uint64) *Stack

                func (*Stack) Dup

                func (st *Stack) Dup(n int)

                func (*Stack) Len

                func (st *Stack) Len() int

                func (*Stack) Peek

                func (st *Stack) Peek() Word256

                  Not an opcode, costs no gas.

                  func (*Stack) Pop

                  func (st *Stack) Pop() Word256

                  func (*Stack) Pop64

                  func (st *Stack) Pop64() uint64

                  func (*Stack) PopAddress

                  func (st *Stack) PopAddress() crypto.Address

                  func (*Stack) PopBigInt

                  func (st *Stack) PopBigInt() *big.Int

                  func (*Stack) PopBigIntSigned

                  func (st *Stack) PopBigIntSigned() *big.Int

                  func (*Stack) PopBytes

                  func (st *Stack) PopBytes() []byte

                  func (*Stack) Print

                  func (st *Stack) Print(n int)

                  func (*Stack) Push

                  func (st *Stack) Push(d Word256)

                  func (*Stack) Push64

                  func (st *Stack) Push64(i uint64)

                  func (*Stack) PushAddress

                  func (st *Stack) PushAddress(address crypto.Address)

                  func (*Stack) PushBigInt

                  func (st *Stack) PushBigInt(bigInt *big.Int) Word256

                    Pushes the bigInt as a Word256 encoding negative values in 32-byte twos complement and returns the encoded result

                    func (*Stack) PushBytes

                    func (st *Stack) PushBytes(bz []byte)

                      currently only called after sha3.Sha3

                      func (*Stack) Swap

                      func (st *Stack) Swap(n int)

                      Directories

                      Path Synopsis
                      asm
                      bc