Initial commit

genvm/core/context.go

@@ -10,7 +10,7 @@ import (
 )
 
 // Context serves 2 purposes:
-// - maintains changes to the system state, that will be applied only after succeful execution
+// - maintains changes to the system state, that will be applied only after successful execution
 // - accumulates set of reusable objects and data.
 type Context struct {
 	Registry HandlerRegistry

vm/core/context.go

@@ -0,0 +1,286 @@
+package core
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/spacemeshos/go-scale"
+
+	"github.com/spacemeshos/go-spacemesh/common/types"
+)
+
+// Context serves 2 purposes:
+// - maintains changes to the system state, that will be applied only after successful execution
+// - accumulates set of reusable objects and data.
+type Context struct {
+	Registry HandlerRegistry
+	Loader   AccountLoader
+
+	// LayerID of the block.
+	LayerID   LayerID
+	GenesisID types.Hash20
+
+	PrincipalHandler  Handler
+	PrincipalTemplate Template
+	PrincipalAccount  Account
+
+	ParseOutput ParseOutput
+	Gas         struct {
+		BaseGas  uint64
+		FixedGas uint64
+	}
+	Header Header
+	Args   scale.Encodable
+
+	// consumed is in gas units and will be used
+	consumed uint64
+	// fee is in coins units
+	fee uint64
+	// an amount transfrered to other accounts
+	transferred uint64
+
+	touched []Address
+	changed map[Address]*Account
+}
+
+// Principal returns address of the account that signed transaction.
+func (c *Context) Principal() Address {
+	return c.PrincipalAccount.Address
+}
+
+// Layer returns block layer id.
+func (c *Context) Layer() LayerID {
+	return c.LayerID
+}
+
+// GetGenesisID returns genesis id.
+func (c *Context) GetGenesisID() Hash20 {
+	return c.GenesisID
+}
+
+// Balance returns the account balance.
+func (c *Context) Balance() uint64 { return c.PrincipalAccount.Balance }
+
+// Template of the principal account.
+func (c *Context) Template() Template {
+	return c.PrincipalTemplate
+}
+
+// Handler of the principal account.
+func (c *Context) Handler() Handler {
+	return c.PrincipalHandler
+}
+
+// Spawn account.
+func (c *Context) Spawn(args scale.Encodable) error {
+	account, err := c.load(ComputePrincipal(c.Header.TemplateAddress, args))
+	if err != nil {
+		return err
+	}
+	if account.TemplateAddress != nil {
+		return ErrSpawned
+	}
+	handler := c.Registry.Get(c.Header.TemplateAddress)
+	if handler == nil {
+		return fmt.Errorf("%w: spawn is called with unknown handler", ErrInternal)
+	}
+	buf := bytes.NewBuffer(nil)
+	instance, err := handler.New(args)
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrMalformed, err)
+	}
+	_, err = instance.EncodeScale(scale.NewEncoder(buf))
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrInternal, err)
+	}
+	account.State = buf.Bytes()
+	account.TemplateAddress = &c.Header.TemplateAddress
+	c.change(account)
+	return nil
+}
+
+// Transfer amount to the address after validation passes.
+func (c *Context) Transfer(to Address, amount uint64) error {
+	return c.transfer(&c.PrincipalAccount, to, amount, c.Header.MaxSpend)
+}
+
+func (c *Context) transfer(from *Account, to Address, amount, max uint64) error {
+	account, err := c.load(to)
+	if err != nil {
+		return err
+	}
+	if amount > from.Balance {
+		return ErrNoBalance
+	}
+	if c.transferred+amount > max {
+		return fmt.Errorf("%w: %d", ErrMaxSpend, max)
+	}
+	// noop. only gas is consumed
+	if from.Address == to {
+		return nil
+	}
+
+	c.transferred += amount
+	from.Balance -= amount
+	account.Balance += amount
+	c.change(account)
+	return nil
+}
+
+// Relay call to the remote account.
+func (c *Context) Relay(remoteTemplate, address Address, call func(Host) error) error {
+	account, err := c.load(address)
+	if err != nil {
+		return err
+	}
+	if account.TemplateAddress == nil {
+		return ErrNotSpawned
+	}
+	if *account.TemplateAddress != remoteTemplate {
+		return fmt.Errorf(
+			"%w: %s != %s",
+			ErrTemplateMismatch,
+			remoteTemplate.String(),
+			account.TemplateAddress.String(),
+		)
+	}
+	handler := c.Registry.Get(remoteTemplate)
+	if handler == nil {
+		panic("template of the spawned account should exist in the registry")
+	}
+	template, err := handler.Load(account.State)
+	if err != nil {
+		return err
+	}
+
+	remote := &RemoteContext{
+		Context:  c,
+		remote:   account,
+		handler:  handler,
+		template: template,
+	}
+	if err := call(remote); err != nil {
+		return err
+	}
+	// ideally such changes would be serialized once for the whole block execution
+	// but it requires more changes in the cache, so can be done as an optimization
+	// if it proves meaningful (most likely wont)
+	buf := bytes.NewBuffer(nil)
+	encoder := scale.NewEncoder(buf)
+	if _, err := template.EncodeScale(encoder); err != nil {
+		return fmt.Errorf("%w: %w", ErrInternal, err)
+	}
+	account.State = buf.Bytes()
+	c.change(account)
+	return nil
+}
+
+// Consume gas from the account after validation passes.
+func (c *Context) Consume(gas uint64) (err error) {
+	amount := gas * c.Header.GasPrice
+	if amount > c.PrincipalAccount.Balance {
+		amount = c.PrincipalAccount.Balance
+		err = ErrOutOfGas
+	} else if total := c.consumed + gas; total > c.Header.MaxGas {
+		gas = c.Header.MaxGas - c.consumed
+		amount = gas * c.Header.GasPrice
+		err = ErrMaxGas
+	}
+	c.consumed += gas
+	c.fee += amount
+	c.PrincipalAccount.Balance -= amount
+	return err
+}
+
+// Apply is executed if transaction was consumed.
+func (c *Context) Apply(updater AccountUpdater) error {
+	c.PrincipalAccount.NextNonce = c.Header.Nonce + 1
+	if err := updater.Update(c.PrincipalAccount); err != nil {
+		return fmt.Errorf("%w: %w", ErrInternal, err)
+	}
+	for _, address := range c.touched {
+		account := c.changed[address]
+		if err := updater.Update(*account); err != nil {
+			return fmt.Errorf("%w: %w", ErrInternal, err)
+		}
+	}
+	return nil
+}
+
+// Consumed gas.
+func (c *Context) Consumed() uint64 {
+	return c.consumed
+}
+
+// Fee computed from consumed gas.
+func (c *Context) Fee() uint64 {
+	return c.fee
+}
+
+// Updated list of addresses.
+func (c *Context) Updated() []types.Address {
+	rst := make([]types.Address, 0, len(c.touched)+1)
+	rst = append(rst, c.PrincipalAccount.Address)
+	rst = append(rst, c.touched...)
+	return rst
+}
+
+func (c *Context) load(address types.Address) (*Account, error) {
+	if address == c.Principal() {
+		return &c.PrincipalAccount, nil
+	}
+	if c.changed == nil {
+		c.changed = map[Address]*Account{}
+	}
+	account, exist := c.changed[address]
+	if !exist {
+		loaded, err := c.Loader.Get(address)
+		if err != nil {
+			return nil, fmt.Errorf("%w: %w", ErrInternal, err)
+		}
+		account = &loaded
+	}
+	return account, nil
+}
+
+func (c *Context) change(account *Account) {
+	if account.Address == c.Principal() {
+		return
+	}
+	_, exist := c.changed[account.Address]
+	if !exist {
+		c.touched = append(c.touched, account.Address)
+	}
+	c.changed[account.Address] = account
+}
+
+// RemoteContext ...
+type RemoteContext struct {
+	*Context
+	remote   *Account
+	handler  Handler
+	template Template
+}
+
+// Balance returns the remote account balance.
+func (r *RemoteContext) Balance() uint64 {
+	return r.remote.Balance
+}
+
+// Template ...
+func (r *RemoteContext) Template() Template {
+	return r.template
+}
+
+// Handler ...
+func (r *RemoteContext) Handler() Handler {
+	return r.handler
+}
+
+// Transfer ...
+func (r *RemoteContext) Transfer(to Address, amount uint64) error {
+	if err := r.transfer(r.remote, to, amount, amount); err != nil {
+		return err
+	}
+	return nil
+}