Documentation

Index

Constants

View Source
const (
	SubscribeBufferSize = 10
)
View Source
const VersionOffset = int64(1)

    Since we have an initial save of our state forest we start one version ahead of the block height, but from then on we should track height by this offset.

    Variables

    This section is empty.

    Functions

    func CallCodeSim

    func CallCodeSim(reader acmstate.Reader, blockchain bcm.BlockchainInfo, fromAddress, address crypto.Address, code, data []byte,
    	logger *logging.Logger) (*exec.TxExecution, error)

      Run the given code on an isolated and unpersisted state Cannot be used to create new contracts.

      func CallSim

      func CallSim(reader acmstate.Reader, blockchain bcm.BlockchainInfo, fromAddress, address crypto.Address, data []byte,
      	logger *logging.Logger) (*exec.TxExecution, error)

        Run a contract's code on an isolated and unpersisted state Cannot be used to create new contracts

        func HeightAtVersion

        func HeightAtVersion(version int64) uint64

        func VMOptions

        func VMOptions(vmOptions evm.Options) func(*executor)

        func VersionAtHeight

        func VersionAtHeight(height uint64) int64

        Types

        type Accounts

        type Accounts struct {
        	burrow_sync.RingMutex
        	acmstate.Reader
        	// contains filtered or unexported fields
        }

          Accounts pairs an underlying state.Reader with a KeyClient to provide a signing variant of an account it also maintains a lock over addresses to provide a linearisation of signing events using SequentialSigningAccount

          func NewAccounts

          func NewAccounts(reader acmstate.Reader, keyClient keys.KeyClient, mutexCount int) *Accounts

          func (*Accounts) SequentialSigningAccount

          func (accs *Accounts) SequentialSigningAccount(address crypto.Address) (*SequentialSigningAccount, error)

          func (*Accounts) SigningAccount

          func (accs *Accounts) SigningAccount(address crypto.Address) (*SigningAccount, error)

          type BatchCommitter

          type BatchCommitter interface {
          	BatchExecutor
          	// Commit execution results to underlying State and provide opportunity to mutate state before it is saved
          	Commit(header *abciTypes.Header) (stateHash []byte, err error)
          }

            Executes transactions

            func NewBatchCommitter

            func NewBatchCommitter(backend ExecutorState, params Params, blockchain engine.Blockchain, emitter *event.Emitter,
            	logger *logging.Logger, options ...Option) (BatchCommitter, error)

            type BatchExecutor

            type BatchExecutor interface {
            	// Provides access to write lock for a BatchExecutor so reads can be prevented for the duration of a commit
            	sync.Locker
            	// Used by execution.Accounts to implement memory pool signing
            	acmstate.Reader
            	// Execute transaction against block cache (i.e. block buffer)
            	Executor
            	// Reset executor to underlying State
            	Reset() error
            }

            func NewBatchChecker

            func NewBatchChecker(backend ExecutorState, params Params, blockchain engine.Blockchain, logger *logging.Logger,
            	options ...Option) (BatchExecutor, error)

              Wraps a cache of what is variously known as the 'check cache' and 'mempool'

              type ExecutionConfig

              type ExecutionConfig struct {
              	// This parameter scales the default Tendermint timeouts. A value of 1 gives the Tendermint defaults designed to
              	// work for 100 node + public network. Smaller networks should be able to sustain lower values.
              	// When running in no-consensus mode (Tendermint.Enabled = false) this scales the block duration with 1.0 meaning 1 second
              	// and 0 meaning commit immediately
              	TimeoutFactor            float64
              	CallStackMaxDepth        uint64
              	DataStackInitialCapacity uint64
              	DataStackMaxDepth        uint64
              	VMOptions                []VMOption `json:",omitempty" toml:",omitempty"`
              }

              func DefaultExecutionConfig

              func DefaultExecutionConfig() *ExecutionConfig

              func (*ExecutionConfig) ExecutionOptions

              func (ec *ExecutionConfig) ExecutionOptions() ([]Option, error)

              type Executor

              type Executor interface {
              	Execute(txEnv *txs.Envelope) (*exec.TxExecution, error)
              }

              type ExecutorFunc

              type ExecutorFunc func(txEnv *txs.Envelope) (*exec.TxExecution, error)

              func (ExecutorFunc) Execute

              func (f ExecutorFunc) Execute(txEnv *txs.Envelope) (*exec.TxExecution, error)

              type ExecutorState

              type ExecutorState interface {
              	Update(updater func(ws state.Updatable) error) (hash []byte, version int64, err error)
              	LastStoredHeight() (uint64, error)
              	acmstate.IterableReader
              	acmstate.MetadataReader
              	names.Reader
              	registry.Reader
              	proposal.Reader
              	validator.IterableReader
              }

              type Option

              type Option func(*executor)

              type Params

              type Params struct {
              	ChainID           string
              	ProposalThreshold uint64
              }

              func ParamsFromGenesis

              func ParamsFromGenesis(genesisDoc *genesis.GenesisDoc) Params

              type SequentialSigningAccount

              type SequentialSigningAccount struct {
              	Address crypto.Address
              	// contains filtered or unexported fields
              }

              func (*SequentialSigningAccount) Lock

              type SigningAccount

              type SigningAccount struct {
              	*acm.Account
              	crypto.Signer
              }

              type Transactor

              type Transactor struct {
              	BlockchainInfo  bcm.BlockchainInfo
              	Emitter         *event.Emitter
              	MempoolAccounts *Accounts
              	// contains filtered or unexported fields
              }

                Transactor is responsible for helping to formulate, sign, and broadcast transactions to tendermint

                The BroadcastTx* methods are able to work against the mempool Accounts (pending) state rather than the committed (final) Accounts state and can assign a sequence number based on all of the txs seen since the last block - provided these transactions are successfully committed (via DeliverTx) then subsequent transactions will have valid sequence numbers. This allows Burrow to coordinate sequencing and signing for a key it holds or is provided - it is down to the key-holder to manage the mutual information between transactions concurrent within a new block window.

                func NewTransactor

                func NewTransactor(tip bcm.BlockchainInfo, emitter *event.Emitter, mempoolAccounts *Accounts,
                	checkTxAsync txChecker, id p2p.ID, txEncoder txs.Encoder, logger *logging.Logger) *Transactor

                func (*Transactor) BroadcastTxAsync

                func (trans *Transactor) BroadcastTxAsync(ctx context.Context, txEnv *txs.Envelope) (*txs.Receipt, error)

                  Broadcast a transaction without waiting for confirmation - will attempt to sign server-side and set sequence numbers if no signatures are provided

                  func (*Transactor) BroadcastTxSync

                  func (trans *Transactor) BroadcastTxSync(ctx context.Context, txEnv *txs.Envelope) (*exec.TxExecution, error)

                  func (*Transactor) CheckTxAsync

                  func (trans *Transactor) CheckTxAsync(txEnv *txs.Envelope, callback func(res *abciTypes.Response)) error

                  func (*Transactor) CheckTxAsyncRaw

                  func (trans *Transactor) CheckTxAsyncRaw(txBytes []byte, callback func(res *abciTypes.Response)) error

                  func (*Transactor) CheckTxSync

                  func (trans *Transactor) CheckTxSync(ctx context.Context, txEnv *txs.Envelope) (*txs.Receipt, error)

                    Broadcast a transaction and waits for a response from the mempool. Transactions to BroadcastTx will block during various mempool operations (managed by Tendermint) including mempool Reap, Commit, and recheckTx.

                    func (*Transactor) CheckTxSyncRaw

                    func (trans *Transactor) CheckTxSyncRaw(ctx context.Context, txBytes []byte) (*txs.Receipt, error)

                    func (*Transactor) MaybeSignTxMempool

                    func (trans *Transactor) MaybeSignTxMempool(txEnv *txs.Envelope) (UnlockFunc, error)

                    func (*Transactor) SignTx

                    func (trans *Transactor) SignTx(txEnv *txs.Envelope) (*txs.Envelope, error)

                    func (*Transactor) SignTxMempool

                    func (trans *Transactor) SignTxMempool(txEnv *txs.Envelope) (*txs.Envelope, UnlockFunc, error)

                    type UnlockFunc

                    type UnlockFunc func()

                    type VMOption

                    type VMOption string
                    const (
                    	DebugOpcodes VMOption = "DebugOpcodes"
                    	DumpTokens   VMOption = "DumpTokens"
                    )