diff --git a/account/account_test.go b/account/account_test.go
index ca3e41fdba161931d24a8610ded01aee33301110..68a5b1eef23b67083ce9295953ca06700763ce50 100644
--- a/account/account_test.go
+++ b/account/account_test.go
@@ -22,8 +22,7 @@ import (
"fmt"
"github.com/hyperledger/burrow/crypto"
- "github.com/hyperledger/burrow/permission"
- "github.com/hyperledger/burrow/permission/types"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/go-wire"
@@ -79,10 +78,10 @@ func TestAccountSerialise(t *testing.T) {
func TestDecodeConcrete(t *testing.T) {
concreteAcc := NewConcreteAccountFromSecret("Super Semi Secret")
- concreteAcc.Permissions = types.AccountPermissions{
- Base: types.BasePermissions{
- Perms: permission.SetGlobal,
- SetBit: permission.SetGlobal,
+ concreteAcc.Permissions = ptypes.AccountPermissions{
+ Base: ptypes.BasePermissions{
+ Perms: ptypes.SetGlobal,
+ SetBit: ptypes.SetGlobal,
},
Roles: []string{"bums"},
}
diff --git a/account/state/state_cache_test.go b/account/state/state_cache_test.go
index 92171155cf68cf2d796a83159c6d1fcb0ee14bb9..6df18eb923680239f1feb1268f39a5d135eac463 100644
--- a/account/state/state_cache_test.go
+++ b/account/state/state_cache_test.go
@@ -1,15 +1,14 @@
package state
import (
- "testing"
-
"fmt"
+ "testing"
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/execution/evm/asm"
- "github.com/hyperledger/burrow/permission"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -290,11 +289,11 @@ func TestStateCache_get(t *testing.T) {
func testAccounts() *MemoryState {
acc1 := acm.NewConcreteAccountFromSecret("acc1")
- acc1.Permissions.Base.Perms = permission.AddRole | permission.Send
+ acc1.Permissions.Base.Perms = ptypes.AddRole | ptypes.Send
acc1.Permissions.Base.SetBit = acc1.Permissions.Base.Perms
acc2 := acm.NewConcreteAccountFromSecret("acc2")
- acc2.Permissions.Base.Perms = permission.AddRole | permission.Send
+ acc2.Permissions.Base.Perms = ptypes.AddRole | ptypes.Send
acc2.Permissions.Base.SetBit = acc1.Permissions.Base.Perms
acc2.Code, _ = acm.NewBytecode(asm.PUSH1, 0x20)
diff --git a/client/rpc/client.go b/client/rpc/client.go
index e940ee3e15e1a26d442309d04088618ca110c90b..9e5364246cc38ae2975b50f2252391db73ae46be 100644
--- a/client/rpc/client.go
+++ b/client/rpc/client.go
@@ -19,14 +19,13 @@ import (
"fmt"
"strconv"
- "github.com/hyperledger/burrow/crypto"
- ptypes "github.com/hyperledger/burrow/permission"
- "github.com/hyperledger/burrow/txs/payload"
-
"github.com/hyperledger/burrow/client"
+ "github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/keys"
"github.com/hyperledger/burrow/permission/snatives"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/hyperledger/burrow/txs"
+ "github.com/hyperledger/burrow/txs/payload"
)
//------------------------------------------------------------------------------------
diff --git a/client/websocket_client.go b/client/websocket_client.go
index 81be41982a8cc735f934bcbec2b702dfbbc7a4cb..b06b2fecabacb4f46010c37f4ce7b440ec18a8cf 100644
--- a/client/websocket_client.go
+++ b/client/websocket_client.go
@@ -22,6 +22,7 @@ import (
"encoding/json"
"github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/errors"
exeEvents "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
@@ -170,12 +171,12 @@ func (burrowNodeWebsocketClient *burrowNodeWebsocketClient) WaitForConfirmation(
continue
}
- if eventDataTx.Exception != "" {
+ if eventDataTx.Exception != nil {
confirmationChannel <- Confirmation{
BlockHash: latestBlockHash,
EventDataTx: eventDataTx,
- Exception: fmt.Errorf("transaction confirmed but execution gave exception: %v",
- eventDataTx.Exception),
+ Exception: errors.Wrap(eventDataTx.Exception,
+ "transaction confirmed but execution gave exception: %v"),
Error: nil,
}
return
diff --git a/core/kernel_test.go b/core/kernel_test.go
index 68cb5f9dd34264b09d0d65de7c577cf26d55eaa8..d242de8e9946a882c68cd54e894a156168248754 100644
--- a/core/kernel_test.go
+++ b/core/kernel_test.go
@@ -2,13 +2,11 @@ package core
import (
"context"
+ "fmt"
"os"
"testing"
-
"time"
- "fmt"
-
"github.com/hyperledger/burrow/consensus/tendermint"
"github.com/hyperledger/burrow/consensus/tendermint/validator"
"github.com/hyperledger/burrow/genesis"
@@ -16,8 +14,8 @@ import (
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/rpc"
"github.com/stretchr/testify/assert"
- tm_config "github.com/tendermint/tendermint/config"
- tm_types "github.com/tendermint/tendermint/types"
+ tmConfig "github.com/tendermint/tendermint/config"
+ tmTypes "github.com/tendermint/tendermint/types"
)
const testDir = "./test_scratch/kernel_test"
@@ -26,7 +24,7 @@ func TestBootThenShutdown(t *testing.T) {
os.RemoveAll(testDir)
os.MkdirAll(testDir, 0777)
os.Chdir(testDir)
- tmConf := tm_config.DefaultConfig()
+ tmConf := tmConfig.DefaultConfig()
//logger, _, _ := lifecycle.NewStdErrLogger()
logger := logging.NewNoopLogger()
genesisDoc, _, privateValidators := genesis.NewDeterministicGenesis(123).GenesisDoc(1, true, 1000, 1, true, 1000)
@@ -38,7 +36,7 @@ func TestBootShutdownResume(t *testing.T) {
os.RemoveAll(testDir)
os.MkdirAll(testDir, 0777)
os.Chdir(testDir)
- tmConf := tm_config.DefaultConfig()
+ tmConf := tmConfig.DefaultConfig()
//logger, _, _ := lifecycle.NewStdErrLogger()
logger := logging.NewNoopLogger()
genesisDoc, _, privateValidators := genesis.NewDeterministicGenesis(123).GenesisDoc(1, true, 1000, 1, true, 1000)
@@ -46,7 +44,7 @@ func TestBootShutdownResume(t *testing.T) {
i := int64(1)
// asserts we get a consecutive run of blocks
- blockChecker := func(block *tm_types.EventDataNewBlock) bool {
+ blockChecker := func(block *tmTypes.EventDataNewBlock) bool {
assert.Equal(t, i, block.Block.Height)
i++
// stop every third block
@@ -61,9 +59,9 @@ func TestBootShutdownResume(t *testing.T) {
assert.Error(t, bootWaitBlocksShutdown(privValidator, genesisDoc, tmConf, logger, blockChecker))
}
-func bootWaitBlocksShutdown(privValidator tm_types.PrivValidator, genesisDoc *genesis.GenesisDoc,
- tmConf *tm_config.Config, logger *logging.Logger,
- blockChecker func(block *tm_types.EventDataNewBlock) (cont bool)) error {
+func bootWaitBlocksShutdown(privValidator tmTypes.PrivValidator, genesisDoc *genesis.GenesisDoc,
+ tmConf *tmConfig.Config, logger *logging.Logger,
+ blockChecker func(block *tmTypes.EventDataNewBlock) (cont bool)) error {
keyStore := keys.NewKeyStore(keys.DefaultKeysDir, false, logger)
keyClient := keys.NewLocalKeyClient(keyStore, logging.NewNoopLogger())
@@ -78,7 +76,7 @@ func bootWaitBlocksShutdown(privValidator tm_types.PrivValidator, genesisDoc *ge
return err
}
- ch := make(chan *tm_types.EventDataNewBlock)
+ ch := make(chan *tmTypes.EventDataNewBlock)
tendermint.SubscribeNewBlock(context.Background(), kern.Emitter, "TestBootShutdownResume", ch)
cont := true
for cont {
diff --git a/execution/errors/errors.go b/execution/errors/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..4f2e2ab8b5d69ab7a7f23dbc08b4df1a38a31c79
--- /dev/null
+++ b/execution/errors/errors.go
@@ -0,0 +1,134 @@
+package errors
+
+import (
+ "fmt"
+)
+
+type CodedError interface {
+ error
+ ErrorCode() ErrorCode
+}
+
+type ErrorCode int8
+
+const (
+ ErrorCodeGeneric ErrorCode = iota
+ ErrorCodeUnknownAddress
+ ErrorCodeInsufficientBalance
+ ErrorCodeInvalidJumpDest
+ ErrorCodeInsufficientGas
+ ErrorCodeMemoryOutOfBounds
+ ErrorCodeCodeOutOfBounds
+ ErrorCodeInputOutOfBounds
+ ErrorCodeReturnDataOutOfBounds
+ ErrorCodeCallStackOverflow
+ ErrorCodeCallStackUnderflow
+ ErrorCodeDataStackOverflow
+ ErrorCodeDataStackUnderflow
+ ErrorCodeInvalidContract
+ ErrorCodeNativeContractCodeCopy
+ ErrorCodeExecutionAborted
+ ErrorCodeExecutionReverted
+ ErrorCodePermissionDenied
+ ErrorCodeNativeFunction
+)
+
+func (ec ErrorCode) ErrorCode() ErrorCode {
+ return ec
+}
+
+func (ec ErrorCode) Error() string {
+ switch ec {
+ case ErrorCodeUnknownAddress:
+ return "Unknown address"
+ case ErrorCodeInsufficientBalance:
+ return "Insufficient balance"
+ case ErrorCodeInvalidJumpDest:
+ return "Invalid jump dest"
+ case ErrorCodeInsufficientGas:
+ return "Insufficient gas"
+ case ErrorCodeMemoryOutOfBounds:
+ return "Memory out of bounds"
+ case ErrorCodeCodeOutOfBounds:
+ return "Code out of bounds"
+ case ErrorCodeInputOutOfBounds:
+ return "Input out of bounds"
+ case ErrorCodeReturnDataOutOfBounds:
+ return "Return data out of bounds"
+ case ErrorCodeCallStackOverflow:
+ return "Call stack overflow"
+ case ErrorCodeCallStackUnderflow:
+ return "Call stack underflow"
+ case ErrorCodeDataStackOverflow:
+ return "Data stack overflow"
+ case ErrorCodeDataStackUnderflow:
+ return "Data stack underflow"
+ case ErrorCodeInvalidContract:
+ return "Invalid contract"
+ case ErrorCodeNativeContractCodeCopy:
+ return "Tried to copy native contract code"
+ case ErrorCodeExecutionAborted:
+ return "Execution aborted"
+ case ErrorCodeExecutionReverted:
+ return "Execution reverted"
+ case ErrorCodeNativeFunction:
+ return "Native function error"
+ default:
+ return "Generic error"
+ }
+}
+
+// Exception provides a serialisable coded error for the VM
+type Exception struct {
+ Code ErrorCode
+ Exception string
+}
+
+func NewCodedError(errorCode ErrorCode, exception string) *Exception {
+ if exception == "" {
+ return nil
+ }
+ return &Exception{
+ Code: errorCode,
+ Exception: exception,
+ }
+}
+
+// Wraps any error as a Exception
+func AsCodedError(err error) *Exception {
+ if err == nil {
+ return nil
+ }
+ switch e := err.(type) {
+ case *Exception:
+ return e
+ case CodedError:
+ return NewCodedError(e.ErrorCode(), e.Error())
+ default:
+ return NewCodedError(ErrorCodeGeneric, err.Error())
+ }
+}
+
+func Wrap(err CodedError, message string) *Exception {
+ return NewCodedError(err.ErrorCode(), message+": "+err.Error())
+}
+
+func Errorf(format string, a ...interface{}) CodedError {
+ return ErrorCodef(ErrorCodeGeneric, format, a...)
+}
+
+func ErrorCodef(errorCode ErrorCode, format string, a ...interface{}) CodedError {
+ return NewCodedError(errorCode, fmt.Sprintf(format, a...))
+}
+
+func (e *Exception) ErrorCode() ErrorCode {
+ return e.Code
+}
+
+func (e *Exception) String() string {
+ return e.Error()
+}
+
+func (e *Exception) Error() string {
+ return fmt.Sprintf("VM Error %v: %s", e.Code, e.Exception)
+}
diff --git a/execution/errors/native.go b/execution/errors/native.go
new file mode 100644
index 0000000000000000000000000000000000000000..df35e9a4f1379b37c6368764156e214ed0a70087
--- /dev/null
+++ b/execution/errors/native.go
@@ -0,0 +1,20 @@
+package errors
+
+import (
+ "fmt"
+
+ "github.com/hyperledger/burrow/crypto"
+)
+
+type LacksSNativePermission struct {
+ Address crypto.Address
+ SNative string
+}
+
+func (e LacksSNativePermission) Error() string {
+ return fmt.Sprintf("account %s does not have SNative function call permission: %s", e.Address, e.SNative)
+}
+
+func (e LacksSNativePermission) ErrorCode() ErrorCode {
+ return ErrorCodeNativeFunction
+}
diff --git a/execution/errors/vm.go b/execution/errors/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..d8b164c230fd94e490dd4bd91154fad93a68f9fb
--- /dev/null
+++ b/execution/errors/vm.go
@@ -0,0 +1,60 @@
+package errors
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/permission/types"
+)
+
+type PermissionDenied struct {
+ Perm types.PermFlag
+}
+
+func (err PermissionDenied) ErrorCode() ErrorCode {
+ return ErrorCodePermissionDenied
+}
+
+func (err PermissionDenied) Error() string {
+ return fmt.Sprintf("Contract does not have permission to %v", err.Perm)
+}
+
+type NestedCall struct {
+ NestedError CodedError
+ Caller crypto.Address
+ Callee crypto.Address
+ StackDepth int
+}
+
+func (err NestedCall) ErrorCode() ErrorCode {
+ return err.NestedError.ErrorCode()
+}
+
+func (err NestedCall) Error() string {
+ return fmt.Sprintf("error in nested call at depth %v: %s (callee) -> %s (caller): %v",
+ err.StackDepth, err.Callee, err.Caller, err.NestedError)
+}
+
+type Call struct {
+ CallError CodedError
+ NestedErrors []NestedCall
+}
+
+func (err Call) ErrorCode() ErrorCode {
+ return err.CallError.ErrorCode()
+}
+
+func (err Call) Error() string {
+ buf := new(bytes.Buffer)
+ buf.WriteString("call error: ")
+ buf.WriteString(err.CallError.Error())
+ if len(err.NestedErrors) > 0 {
+ buf.WriteString(", nested call errors:\n")
+ for _, nestedErr := range err.NestedErrors {
+ buf.WriteString(nestedErr.Error())
+ buf.WriteByte('\n')
+ }
+ }
+ return buf.String()
+}
diff --git a/execution/events/events.go b/execution/events/events.go
index fd28bfe896d42f7e8910f5cf208028c7c0f658a3..6a7e64faa7e725a2838eb08865c5f2ab266a6440 100644
--- a/execution/events/events.go
+++ b/execution/events/events.go
@@ -7,6 +7,8 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/hyperledger/burrow/txs"
"github.com/hyperledger/burrow/txs/payload"
"github.com/tmthrgd/go-hex"
@@ -15,7 +17,7 @@ import (
func EventStringAccountInput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Input", addr) }
func EventStringAccountOutput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Output", addr) }
func EventStringNameReg(name string) string { return fmt.Sprintf("NameReg/%s", name) }
-func EventStringPermissions(name string) string { return fmt.Sprintf("Permissions/%s", name) }
+func EventStringPermissions(perm ptypes.PermFlag) string { return fmt.Sprintf("Permissions/%v", perm) }
func EventStringBond() string { return "Bond" }
func EventStringUnbond() string { return "Unbond" }
func EventStringRebond() string { return "Rebond" }
@@ -24,7 +26,7 @@ func EventStringRebond() string { return "Rebond" }
type EventDataTx struct {
Tx *txs.Tx
Return []byte
- Exception string
+ Exception *errors.Exception
}
// For re-use
@@ -54,7 +56,7 @@ func SubscribeAccountOutputSendTx(ctx context.Context, subscribable event.Subscr
}
func PublishAccountOutput(publisher event.Publisher, address crypto.Address, tx *txs.Tx, ret []byte,
- exception string) error {
+ exception *errors.Exception) error {
return event.PublishWithEventID(publisher, EventStringAccountOutput(address),
&EventDataTx{
@@ -70,7 +72,7 @@ func PublishAccountOutput(publisher event.Publisher, address crypto.Address, tx
}
func PublishAccountInput(publisher event.Publisher, address crypto.Address, tx *txs.Tx, ret []byte,
- exception string) error {
+ exception *errors.Exception) error {
return event.PublishWithEventID(publisher, EventStringAccountInput(address),
&EventDataTx{
@@ -98,14 +100,14 @@ func PublishNameReg(publisher event.Publisher, tx *txs.Tx) error {
})
}
-func PublishPermissions(publisher event.Publisher, name string, tx *txs.Tx) error {
+func PublishPermissions(publisher event.Publisher, perm ptypes.PermFlag, tx *txs.Tx) error {
_, ok := tx.Payload.(*payload.PermissionsTx)
if !ok {
return fmt.Errorf("Tx payload must be PermissionsTx to PublishPermissions")
}
- return event.PublishWithEventID(publisher, EventStringPermissions(name), &EventDataTx{Tx: tx},
+ return event.PublishWithEventID(publisher, EventStringPermissions(perm), &EventDataTx{Tx: tx},
map[string]interface{}{
- "name": name,
+ "name": perm.String(),
event.TxTypeKey: tx.Type().String(),
event.TxHashKey: hex.EncodeUpperToString(tx.Hash()),
})
diff --git a/execution/evm/events/events.go b/execution/evm/events/events.go
index 9ae628a7a829ac0c858811cd5643910abbffc7da..9095d7687fa84b88a99585bdecf5e7a2d420fa04 100644
--- a/execution/evm/events/events.go
+++ b/execution/evm/events/events.go
@@ -21,6 +21,7 @@ import (
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
"github.com/tmthrgd/go-hex"
)
@@ -38,7 +39,7 @@ type EventDataCall struct {
TxHash []byte
StackDepth int
Return []byte
- Exception string
+ Exception *errors.Exception
}
type CallData struct {
diff --git a/execution/evm/native.go b/execution/evm/native.go
index 70f00ed6d2a25c31a42de210f29161f0905cb68b..4a7c7e615141faf3dd92b50fe4ec095d6a8cbdb4 100644
--- a/execution/evm/native.go
+++ b/execution/evm/native.go
@@ -20,13 +20,15 @@ import (
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/account/state"
. "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/errors"
"github.com/hyperledger/burrow/logging"
"golang.org/x/crypto/ripemd160"
)
var registeredNativeContracts = make(map[Word256]NativeContract)
-func RegisteredNativeContract(address Word256) bool {
+func IsRegisteredNativeContract(address Word256) bool {
_, ok := registeredNativeContracts[address]
return ok
}
@@ -54,6 +56,21 @@ func registerNativeContracts() {
//-----------------------------------------------------------------------------
+func ExecuteNativeContract(address Word256, state state.Writer, caller acm.Account, input []byte, gas *uint64,
+ logger *logging.Logger) ([]byte, errors.CodedError) {
+
+ contract, ok := registeredNativeContracts[address]
+ if !ok {
+ return nil, errors.ErrorCodef(errors.ErrorCodeNativeFunction,
+ "no native contract registered at address: %v", crypto.AddressFromWord256(address))
+ }
+ output, err := contract(state, caller, input, gas, logger)
+ if err != nil {
+ return nil, errors.NewCodedError(errors.ErrorCodeNativeFunction, err.Error())
+ }
+ return output, nil
+}
+
type NativeContract func(state state.Writer, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error)
@@ -86,7 +103,7 @@ func sha256Func(state state.Writer, caller acm.Account, input []byte, gas *uint6
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasSha256Word + GasSha256Base
if *gas < gasRequired {
- return nil, ErrInsufficientGas
+ return nil, errors.ErrorCodeInsufficientGas
} else {
*gas -= gasRequired
}
@@ -102,7 +119,7 @@ func ripemd160Func(state state.Writer, caller acm.Account, input []byte, gas *ui
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasRipemd160Word + GasRipemd160Base
if *gas < gasRequired {
- return nil, ErrInsufficientGas
+ return nil, errors.ErrorCodeInsufficientGas
} else {
*gas -= gasRequired
}
@@ -118,7 +135,7 @@ func identityFunc(state state.Writer, caller acm.Account, input []byte, gas *uin
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasIdentityWord + GasIdentityBase
if *gas < gasRequired {
- return nil, ErrInsufficientGas
+ return nil, errors.ErrorCodeInsufficientGas
} else {
*gas -= gasRequired
}
diff --git a/execution/evm/snative.go b/execution/evm/snative.go
index 8afbd171c84ed8a05e72c948dcc231958bfd4ee8..7f9c25e57ff60891305b15c58edd02fcb827aed1 100644
--- a/execution/evm/snative.go
+++ b/execution/evm/snative.go
@@ -23,11 +23,11 @@ import (
"github.com/hyperledger/burrow/account/state"
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/errors"
"github.com/hyperledger/burrow/execution/evm/abi"
"github.com/hyperledger/burrow/execution/evm/sha3"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
- "github.com/hyperledger/burrow/permission"
ptypes "github.com/hyperledger/burrow/permission/types"
)
@@ -98,7 +98,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_role", roleTypeName),
},
abiReturn("result", abi.BoolTypeName),
- permission.AddRole,
+ ptypes.AddRole,
addRole},
&SNativeFunctionDescription{`
@@ -113,7 +113,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_role", roleTypeName),
},
abiReturn("result", abi.BoolTypeName),
- permission.RemoveRole,
+ ptypes.RemoveRole,
removeRole},
&SNativeFunctionDescription{`
@@ -128,7 +128,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_role", roleTypeName),
},
abiReturn("result", abi.BoolTypeName),
- permission.HasRole,
+ ptypes.HasRole,
hasRole},
&SNativeFunctionDescription{`
@@ -145,7 +145,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_set", abi.BoolTypeName),
},
abiReturn("result", permFlagTypeName),
- permission.SetBase,
+ ptypes.SetBase,
setBase},
&SNativeFunctionDescription{`
@@ -159,7 +159,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_account", abi.AddressTypeName),
abiArg("_permission", permFlagTypeName)},
abiReturn("result", permFlagTypeName),
- permission.UnsetBase,
+ ptypes.UnsetBase,
unsetBase},
&SNativeFunctionDescription{`
@@ -173,7 +173,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_account", abi.AddressTypeName),
abiArg("_permission", permFlagTypeName)},
abiReturn("result", abi.BoolTypeName),
- permission.HasBase,
+ ptypes.HasBase,
hasBase},
&SNativeFunctionDescription{`
@@ -187,7 +187,7 @@ func SNativeContracts() map[string]*SNativeContractDescription {
abiArg("_permission", permFlagTypeName),
abiArg("_set", abi.BoolTypeName)},
abiReturn("result", permFlagTypeName),
- permission.SetGlobal,
+ ptypes.SetGlobal,
setGlobal},
),
}
@@ -227,15 +227,6 @@ func NewSNativeContract(comment, name string,
}
}
-type ErrLacksSNativePermission struct {
- Address crypto.Address
- SNative string
-}
-
-func (e ErrLacksSNativePermission) Error() string {
- return fmt.Sprintf("account %s does not have SNative function call permission: %s", e.Address, e.SNative)
-}
-
// This function is designed to be called from the EVM once a SNative contract
// has been selected. It is also placed in a registry by registerSNativeContracts
// So it can be looked up by SNative address
@@ -245,8 +236,9 @@ func (contract *SNativeContractDescription) Dispatch(state state.Writer, caller
logger = logger.With(structure.ScopeKey, "Dispatch", "contract_name", contract.Name)
if len(args) < abi.FunctionSelectorLength {
- return nil, fmt.Errorf("SNatives dispatch requires a 4-byte function "+
- "identifier but arguments are only %v bytes long", len(args))
+ return nil, errors.ErrorCodef(errors.ErrorCodeNativeFunction,
+ "SNatives dispatch requires a 4-byte function identifier but arguments are only %v bytes long",
+ len(args))
}
function, err := contract.FunctionByID(abi.FirstFourBytes(args))
@@ -262,12 +254,12 @@ func (contract *SNativeContractDescription) Dispatch(state state.Writer, caller
// check if we have permission to call this function
if !HasPermission(state, caller, function.PermFlag) {
- return nil, ErrLacksSNativePermission{caller.Address(), function.Name}
+ return nil, errors.LacksSNativePermission{caller.Address(), function.Name}
}
// ensure there are enough arguments
if len(remainingArgs) != function.NArgs()*Word256Length {
- return nil, fmt.Errorf("%s() takes %d arguments but got %d (with %d bytes unconsumed - should be 0)",
+ return nil, errors.ErrorCodef(errors.ErrorCodeNativeFunction, "%s() takes %d arguments but got %d (with %d bytes unconsumed - should be 0)",
function.Name, function.NArgs(), len(remainingArgs)/Word256Length, len(remainingArgs)%Word256Length)
}
@@ -284,11 +276,11 @@ func (contract *SNativeContractDescription) Address() (address crypto.Address) {
}
// Get function by calling identifier FunctionSelector
-func (contract *SNativeContractDescription) FunctionByID(id abi.FunctionSelector) (*SNativeFunctionDescription, error) {
+func (contract *SNativeContractDescription) FunctionByID(id abi.FunctionSelector) (*SNativeFunctionDescription, errors.CodedError) {
f, ok := contract.functionsByID[id]
if !ok {
return nil,
- fmt.Errorf("unknown SNative function with ID %x", id)
+ errors.ErrorCodef(errors.ErrorCodeNativeFunction, "unknown SNative function with ID %x", id)
}
return f, nil
}
@@ -527,7 +519,7 @@ func removeRole(stateWriter state.Writer, caller acm.Account, args []byte, gas *
// Checks if a permission flag is valid (a known base chain or snative permission)
func ValidPermN(n ptypes.PermFlag) bool {
- return n <= permission.AllPermFlags
+ return n <= ptypes.AllPermFlags
}
// Get the global BasePermissions
diff --git a/execution/evm/snative_test.go b/execution/evm/snative_test.go
index 3f5e5eae9cc0dba28c35f849dd587312b35f65b3..e9b4150db7256f160dede1eaab8e73962fae5cb1 100644
--- a/execution/evm/snative_test.go
+++ b/execution/evm/snative_test.go
@@ -23,10 +23,11 @@ import (
acm "github.com/hyperledger/burrow/account"
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/errors"
"github.com/hyperledger/burrow/execution/evm/abi"
"github.com/hyperledger/burrow/execution/evm/asm/bc"
"github.com/hyperledger/burrow/execution/evm/sha3"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
)
@@ -87,7 +88,7 @@ func TestSNativeContractDescription_Dispatch(t *testing.T) {
if !assert.Error(t, err, "Should fail due to lack of permissions") {
return
}
- assert.IsType(t, err, ErrLacksSNativePermission{})
+ assert.IsType(t, err, errors.LacksSNativePermission{})
// Grant all permissions and dispatch should success
caller.SetPermissions(allAccountPermissions())
diff --git a/execution/evm/stack.go b/execution/evm/stack.go
index 3e9dfd5b8987707f68334e6b56f7044bc8fd409c..9a244265c1cf895955982a4f80dc4307a2d88559 100644
--- a/execution/evm/stack.go
+++ b/execution/evm/stack.go
@@ -20,6 +20,7 @@ import (
"math/big"
. "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/execution/errors"
)
// Not goroutine safe
@@ -28,10 +29,10 @@ type Stack struct {
ptr int
gas *uint64
- err *error
+ err *errors.CodedError
}
-func NewStack(capacity int, gas *uint64, err *error) *Stack {
+func NewStack(capacity int, gas *uint64, err *errors.CodedError) *Stack {
return &Stack{
data: make([]Word256, capacity),
ptr: 0,
@@ -44,11 +45,11 @@ func (st *Stack) useGas(gasToUse uint64) {
if *st.gas > gasToUse {
*st.gas -= gasToUse
} else {
- st.setErr(ErrInsufficientGas)
+ st.setErr(errors.ErrorCodeInsufficientGas)
}
}
-func (st *Stack) setErr(err error) {
+func (st *Stack) setErr(err errors.CodedError) {
if *st.err == nil {
*st.err = err
}
@@ -57,7 +58,7 @@ func (st *Stack) setErr(err error) {
func (st *Stack) Push(d Word256) {
st.useGas(GasStackOp)
if st.ptr == cap(st.data) {
- st.setErr(ErrDataStackOverflow)
+ st.setErr(errors.ErrorCodeDataStackOverflow)
return
}
st.data[st.ptr] = d
@@ -92,7 +93,7 @@ func (st *Stack) PushBigInt(bigInt *big.Int) Word256 {
func (st *Stack) Pop() Word256 {
st.useGas(GasStackOp)
if st.ptr == 0 {
- st.setErr(ErrDataStackUnderflow)
+ st.setErr(errors.ErrorCodeDataStackUnderflow)
return Zero256
}
st.ptr--
@@ -103,18 +104,18 @@ func (st *Stack) PopBytes() []byte {
return st.Pop().Bytes()
}
-func (st *Stack) Pop64() (int64, error) {
+func (st *Stack) Pop64() (int64, errors.CodedError) {
d := st.Pop()
if Is64BitOverflow(d) {
- return 0, fmt.Errorf("int64 overflow from word: %v", d)
+ return 0, errors.ErrorCodef(errors.ErrorCodeCallStackOverflow, "int64 overflow from word: %v", d)
}
return Int64FromWord256(d), nil
}
-func (st *Stack) PopU64() (uint64, error) {
+func (st *Stack) PopU64() (uint64, errors.CodedError) {
d := st.Pop()
if Is64BitOverflow(d) {
- return 0, fmt.Errorf("uint64 overflow from word: %v", d)
+ return 0, errors.ErrorCodef(errors.ErrorCodeCallStackOverflow, "int64 overflow from word: %v", d)
}
return Uint64FromWord256(d), nil
}
@@ -135,7 +136,7 @@ func (st *Stack) Len() int {
func (st *Stack) Swap(n int) {
st.useGas(GasStackOp)
if st.ptr < n {
- st.setErr(ErrDataStackUnderflow)
+ st.setErr(errors.ErrorCodeDataStackUnderflow)
return
}
st.data[st.ptr-n], st.data[st.ptr-1] = st.data[st.ptr-1], st.data[st.ptr-n]
@@ -144,7 +145,7 @@ func (st *Stack) Swap(n int) {
func (st *Stack) Dup(n int) {
st.useGas(GasStackOp)
if st.ptr < n {
- st.setErr(ErrDataStackUnderflow)
+ st.setErr(errors.ErrorCodeDataStackUnderflow)
return
}
st.Push(st.data[st.ptr-n])
@@ -153,7 +154,7 @@ func (st *Stack) Dup(n int) {
// Not an opcode, costs no gas.
func (st *Stack) Peek() Word256 {
if st.ptr == 0 {
- st.setErr(ErrDataStackUnderflow)
+ st.setErr(errors.ErrorCodeDataStackUnderflow)
return Zero256
}
return st.data[st.ptr-1]
diff --git a/execution/evm/vm.go b/execution/evm/vm.go
index 37e9ec0658cc31da92b6979453833772acb7d606..ec4eb07e1e02f96ec6116da7ff978b8474a02efc 100644
--- a/execution/evm/vm.go
+++ b/execution/evm/vm.go
@@ -16,7 +16,6 @@ package evm
import (
"bytes"
- "errors"
"fmt"
"io/ioutil"
"math/big"
@@ -27,77 +26,19 @@ import (
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
. "github.com/hyperledger/burrow/execution/evm/asm"
"github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/execution/evm/sha3"
"github.com/hyperledger/burrow/logging"
- "github.com/hyperledger/burrow/permission"
ptypes "github.com/hyperledger/burrow/permission/types"
)
-var (
- ErrUnknownAddress = errors.New("Unknown address")
- ErrInsufficientBalance = errors.New("Insufficient balance")
- ErrInvalidJumpDest = errors.New("Invalid jump dest")
- ErrInsufficientGas = errors.New("Insufficient gas")
- ErrMemoryOutOfBounds = errors.New("Memory out of bounds")
- ErrCodeOutOfBounds = errors.New("Code out of bounds")
- ErrInputOutOfBounds = errors.New("Input out of bounds")
- ErrReturnDataOutOfBounds = errors.New("Return data out of bounds")
- ErrCallStackOverflow = errors.New("Call stack overflow")
- ErrCallStackUnderflow = errors.New("Call stack underflow")
- ErrDataStackOverflow = errors.New("Data stack overflow")
- ErrDataStackUnderflow = errors.New("Data stack underflow")
- ErrInvalidContract = errors.New("Invalid contract")
- ErrNativeContractCodeCopy = errors.New("Tried to copy native contract code")
- ErrExecutionAborted = errors.New("Execution aborted")
- ErrExecutionReverted = errors.New("Execution reverted")
-)
-
const (
dataStackCapacity = 1024
callStackCapacity = 100 // TODO ensure usage.
)
-type ErrPermission struct {
- typ string
-}
-
-func (err ErrPermission) Error() string {
- return fmt.Sprintf("Contract does not have permission to %s", err.typ)
-}
-
-type ErrNestedCall struct {
- NestedError error
- Caller crypto.Address
- Callee crypto.Address
- StackDepth int
-}
-
-func (err ErrNestedCall) Error() string {
- return fmt.Sprintf("error in nested call at depth %v: %s (callee) -> %s (caller): %v",
- err.StackDepth, err.Callee, err.Caller, err.NestedError)
-}
-
-type ErrCall struct {
- CallError error
- NestedErrors []ErrNestedCall
-}
-
-func (err ErrCall) Error() string {
- buf := new(bytes.Buffer)
- buf.WriteString("call error: ")
- buf.WriteString(err.CallError.Error())
- if len(err.NestedErrors) > 0 {
- buf.WriteString(", nested call errors:\n")
- for _, nestedErr := range err.NestedErrors {
- buf.WriteString(nestedErr.Error())
- buf.WriteByte('\n')
- }
- }
- return buf.String()
-}
-
type Params struct {
BlockHeight uint64
BlockHash Word256
@@ -111,7 +52,7 @@ type VM struct {
origin crypto.Address
txHash []byte
stackDepth int
- nestedCallErrors []ErrNestedCall
+ nestedCallErrors []errors.NestedCall
publisher event.Publisher
logger *logging.Logger
returnData []byte
@@ -157,40 +98,41 @@ func HasPermission(stateWriter state.Writer, acc acm.Account, perm ptypes.PermFl
return value
}
-func (vm *VM) fireCallEvent(exception *string, output *[]byte, callerAddress, calleeAddress crypto.Address, input []byte, value uint64, gas *uint64) {
+func (vm *VM) fireCallEvent(exception *errors.CodedError, output *[]byte, callerAddress, calleeAddress crypto.Address, input []byte, value uint64, gas *uint64) {
// fire the post call event (including exception if applicable)
if vm.publisher != nil {
- events.PublishAccountCall(vm.publisher, calleeAddress, &events.EventDataCall{
- CallData: &events.CallData{
- Caller: callerAddress,
- Callee: calleeAddress,
- Data: input,
- Value: value,
- Gas: *gas,
- },
- Origin: vm.origin,
- TxHash: vm.txHash,
- StackDepth: vm.stackDepth,
- Return: *output,
- Exception: *exception,
- })
+ events.PublishAccountCall(vm.publisher, calleeAddress,
+ &events.EventDataCall{
+ CallData: &events.CallData{
+ Caller: callerAddress,
+ Callee: calleeAddress,
+ Data: input,
+ Value: value,
+ Gas: *gas,
+ },
+ Origin: vm.origin,
+ TxHash: vm.txHash,
+ StackDepth: vm.stackDepth,
+ Return: *output,
+ Exception: errors.AsCodedError(*exception),
+ })
}
}
// CONTRACT state is aware of caller and callee, so we can just mutate them.
// CONTRACT code and input are not mutated.
// CONTRACT returned 'ret' is a new compact slice.
-// value: To be transferred from caller to callee. Refunded upon error.
+// value: To be transferred from caller to callee. Refunded upon errors.CodedError.
// gas: Available gas. No refunds for gas.
// code: May be nil, since the CALL opcode may be used to send value from contracts to accounts
-func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err error) {
+func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
- exception := new(string)
+ exception := new(errors.CodedError)
// fire the post call event (including exception if applicable)
defer vm.fireCallEvent(exception, &output, caller.Address(), callee.Address(), input, value, gas)
if err = transfer(caller, callee, value); err != nil {
- *exception = err.Error()
+ *exception = err
return
}
//childCallState
@@ -201,15 +143,14 @@ func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, cod
output, err = vm.call(childCallState, caller, callee, code, input, value, gas)
vm.stackDepth -= 1
if err != nil {
- err = ErrCall{
+ *exception = errors.Call{
CallError: err,
NestedErrors: vm.nestedCallErrors,
}
- *exception = err.Error()
transferErr := transfer(callee, caller, value)
if transferErr != nil {
- return nil, fmt.Errorf("error transferring value %v %s (callee) -> %s (caller)",
- value, callee, caller)
+ return nil, errors.Wrap(transferErr,
+ fmt.Sprintf("error transferring value %v %s (callee) -> %s (caller)", value, callee, caller))
}
} else {
// Copy any state updates from child call frame into current call frame
@@ -228,7 +169,7 @@ func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, cod
// The intent of delegate call is to run the code of the callee in the storage context of the caller;
// while preserving the original caller to the previous callee.
// Different to the normal CALL or CALLCODE, the value does not need to be transferred to the callee.
-func (vm *VM) DelegateCall(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err error) {
+func (vm *VM) DelegateCall(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
exception := new(string)
// fire the post call event (including exception if applicable)
@@ -257,18 +198,18 @@ func (vm *VM) DelegateCall(callState state.Cache, caller acm.Account, callee acm
// Try to deduct gasToUse from gasLeft. If ok return false, otherwise
// set err and return true.
-func useGasNegative(gasLeft *uint64, gasToUse uint64, err *error) bool {
+func useGasNegative(gasLeft *uint64, gasToUse uint64, err *errors.CodedError) bool {
if *gasLeft >= gasToUse {
*gasLeft -= gasToUse
return false
} else if *err == nil {
- *err = ErrInsufficientGas
+ *err = errors.ErrorCodeInsufficientGas
}
return true
}
// Just like Call() but does not transfer 'value' or modify the callDepth.
-func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err error) {
+func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
vm.Debugf("(%d) (%X) %X (code=%d) gas: %v (d) %X\n", vm.stackDepth, caller.Address().Bytes()[:4], callee.Address(),
len(callee.Code()), *gas, input)
@@ -555,7 +496,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
data, memErr := memory.Read(offset, size)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
data = sha3.Sha3(data)
stack.PushBytes(data)
@@ -575,7 +516,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
return nil, firstErr(err, errAcc)
}
if acc == nil {
- return nil, firstErr(err, ErrUnknownAddress)
+ return nil, firstErr(err, errors.ErrorCodeUnknownAddress)
}
balance := acc.Balance()
stack.PushU64(balance)
@@ -600,7 +541,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
data, ok := subslice(input, offset, 32)
if !ok {
- return nil, firstErr(err, ErrInputOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeInputOutOfBounds)
}
res := LeftPadWord256(data)
stack.Push(res)
@@ -622,12 +563,12 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
data, ok := subslice(input, inputOff, length)
if !ok {
- return nil, firstErr(err, ErrInputOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeInputOutOfBounds)
}
memErr := memory.Write(memOff, data)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v, %v] %X\n", memOff, inputOff, length, data)
@@ -648,12 +589,12 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
data, ok := subslice(code, codeOff, length)
if !ok {
- return nil, firstErr(err, ErrCodeOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeCodeOutOfBounds)
}
memErr := memory.Write(memOff, data)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v, %v] %X\n", memOff, codeOff, length, data)
@@ -672,7 +613,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
if acc == nil {
if _, ok := registeredNativeContracts[addr]; !ok {
- return nil, firstErr(err, ErrUnknownAddress)
+ return nil, firstErr(err, errors.ErrorCodeUnknownAddress)
}
vm.Debugf(" => returning code size of 1 to indicated existence of native contract at %X\n", addr)
stack.Push(One256)
@@ -694,9 +635,9 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
if acc == nil {
if _, ok := registeredNativeContracts[addr]; ok {
vm.Debugf(" => attempted to copy native contract at %X but this is not supported\n", addr)
- return nil, firstErr(err, ErrNativeContractCodeCopy)
+ return nil, firstErr(err, errors.ErrorCodeNativeContractCodeCopy)
}
- return nil, firstErr(err, ErrUnknownAddress)
+ return nil, firstErr(err, errors.ErrorCodeUnknownAddress)
}
code := acc.Code()
memOff := stack.PopBigInt()
@@ -710,12 +651,12 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
data, ok := subslice(code, codeOff, length)
if !ok {
- return nil, firstErr(err, ErrCodeOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeCodeOutOfBounds)
}
memErr := memory.Write(memOff, data)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v, %v] %X\n", memOff, codeOff, length, data)
@@ -729,7 +670,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
end := new(big.Int).Add(outputOff, length)
if end.BitLen() > 64 || uint64(len(vm.returnData)) < end.Uint64() {
- return nil, ErrReturnDataOutOfBounds
+ return nil, errors.ErrorCodeReturnDataOutOfBounds
}
data := vm.returnData
@@ -737,7 +678,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
memErr := memory.Write(memOff, data)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v, %v] %X\n", memOff, outputOff, length, data)
@@ -772,7 +713,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
data, memErr := memory.Read(offset, BigWord256Length)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
stack.Push(LeftPadWord256(data))
vm.Debugf(" => 0x%X @ 0x%X\n", data, offset)
@@ -782,7 +723,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
memErr := memory.Write(offset, data.Bytes())
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => 0x%X @ 0x%X\n", data, offset)
@@ -796,7 +737,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
memErr := memory.Write(offset, []byte{val})
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v] 0x%X\n", offset, val)
@@ -867,7 +808,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
a := int64(op - PUSH1 + 1)
codeSegment, ok := subslice(code, pc+1, a)
if !ok {
- return nil, firstErr(err, ErrCodeOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeCodeOutOfBounds)
}
res := LeftPadWord256(codeSegment)
stack.Push(res)
@@ -896,7 +837,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
data, memErr := memory.Read(offset, size)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
if vm.publisher != nil {
events.PublishLogEvent(vm.publisher, callee.Address(), &events.EventDataLog{
@@ -911,8 +852,8 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
case CREATE: // 0xF0
vm.returnData = nil
- if !HasPermission(callState, callee, permission.CreateContract) {
- return nil, ErrPermission{"create_contract"}
+ if !HasPermission(callState, callee, ptypes.CreateContract) {
+ return nil, errors.PermissionDenied{Perm: ptypes.CreateContract}
}
contractValue, popErr := stack.PopU64()
if popErr != nil {
@@ -922,16 +863,16 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
input, memErr := memory.Read(offset, size)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
// Check balance
if callee.Balance() < uint64(contractValue) {
- return nil, firstErr(err, ErrInsufficientBalance)
+ return nil, firstErr(err, errors.ErrorCodeInsufficientBalance)
}
// TODO charge for gas to create account _ the code length * GasCreateByte
- var gasErr error
+ var gasErr errors.CodedError
if useGasNegative(gas, GasCreateAccount, &gasErr) {
return nil, firstErr(err, gasErr)
}
@@ -942,24 +883,24 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
// Run the input to get the contract code.
// NOTE: no need to copy 'input' as per Call contract.
- ret, err_ := vm.Call(callState, callee, newAccount, input, input, contractValue, gas)
- if err_ != nil {
+ ret, callErr := vm.Call(callState, callee, newAccount, input, input, contractValue, gas)
+ if callErr != nil {
stack.Push(Zero256)
+ // Note we both set the return buffer and return the result normally
vm.returnData = ret
+ if callErr.ErrorCode() == errors.ErrorCodeExecutionReverted {
+ return ret, callErr
+ }
} else {
newAccount.SetCode(ret) // Set the code (ret need not be copied as per Call contract)
stack.Push(newAccount.Address().Word256())
}
- if err_ == ErrExecutionReverted {
- return nil, ErrExecutionReverted
- }
-
case CALL, CALLCODE, DELEGATECALL: // 0xF1, 0xF2, 0xF4
vm.returnData = nil
- if !HasPermission(callState, callee, permission.Call) {
- return nil, ErrPermission{"call"}
+ if !HasPermission(callState, callee, ptypes.Call) {
+ return nil, errors.PermissionDenied{Perm: ptypes.Call}
}
gasLimit, popErr := stack.PopU64()
if popErr != nil {
@@ -991,12 +932,12 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
args, memErr := memory.Read(inOffset, inSize)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
// Ensure that gasLimit is reasonable
if *gas < gasLimit {
- // EIP150 - the 63/64 rule - rather than error we pass this specified fraction of the total available gas
+ // EIP150 - the 63/64 rule - rather than errors.CodedError we pass this specified fraction of the total available gas
gasLimit = *gas - *gas/64
}
// NOTE: we will return any used gas later.
@@ -1004,19 +945,14 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
// Begin execution
var ret []byte
- var callErr error
+ var callErr errors.CodedError
- if nativeContract := registeredNativeContracts[addr]; nativeContract != nil {
+ if IsRegisteredNativeContract(addr) {
// Native contract
- ret, callErr = nativeContract(callState, callee, args, &gasLimit, logger)
-
+ ret, callErr = ExecuteNativeContract(addr, callState, callee, args, &gasLimit, logger)
// for now we fire the Call event. maybe later we'll fire more particulars
- var exception string
- if callErr != nil {
- exception = callErr.Error()
- }
// NOTE: these fire call go_events and not particular go_events for eg name reg or permissions
- vm.fireCallEvent(&exception, &ret, callee.Address(), crypto.AddressFromWord256(addr), args, value, &gasLimit)
+ vm.fireCallEvent(&callErr, &ret, callee.Address(), crypto.AddressFromWord256(addr), args, value, &gasLimit)
} else {
// EVM contract
if useGasNegative(gas, GasGetAccount, &callErr) {
@@ -1027,24 +963,24 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
return nil, firstErr(callErr, errAcc)
}
// since CALL is used also for sending funds,
- // acc may not exist yet. This is an error for
+ // acc may not exist yet. This is an errors.CodedError for
// CALLCODE, but not for CALL, though I don't think
// ethereum actually cares
if op == CALLCODE {
if acc == nil {
- return nil, firstErr(callErr, ErrUnknownAddress)
+ return nil, firstErr(callErr, errors.ErrorCodeUnknownAddress)
}
ret, callErr = vm.Call(callState, callee, callee, acc.Code(), args, value, &gasLimit)
} else if op == DELEGATECALL {
if acc == nil {
- return nil, firstErr(callErr, ErrUnknownAddress)
+ return nil, firstErr(callErr, errors.ErrorCodeUnknownAddress)
}
ret, callErr = vm.DelegateCall(callState, caller, callee, acc.Code(), args, value, &gasLimit)
} else {
// nil account means we're sending funds to a new account
if acc == nil {
- if !HasPermission(callState, caller, permission.CreateAccount) {
- return nil, ErrPermission{"create_account"}
+ if !HasPermission(callState, caller, ptypes.CreateAccount) {
+ return nil, errors.PermissionDenied{Perm: ptypes.CreateAccount}
}
acc = acm.ConcreteAccount{Address: crypto.AddressFromWord256(addr)}.MutableAccount()
}
@@ -1070,8 +1006,8 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
// Push result
if callErr != nil {
vm.Debugf("error from nested sub-call (depth: %v): %s\n", vm.stackDepth, callErr.Error())
- // So we can return nested error if the top level return is an error
- vm.nestedCallErrors = append(vm.nestedCallErrors, ErrNestedCall{
+ // So we can return nested errors.CodedError if the top level return is an errors.CodedError
+ vm.nestedCallErrors = append(vm.nestedCallErrors, errors.NestedCall{
NestedError: callErr,
StackDepth: vm.stackDepth,
Caller: caller.Address(),
@@ -1079,7 +1015,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
})
stack.Push(Zero256)
- if callErr == ErrExecutionReverted {
+ if callErr.ErrorCode() == errors.ErrorCodeExecutionReverted {
memory.Write(retOffset, RightPadBytes(ret, int(retSize)))
}
} else {
@@ -1091,7 +1027,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
memErr := memory.Write(retOffset, RightPadBytes(ret, int(retSize)))
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(callErr, ErrMemoryOutOfBounds)
+ return nil, firstErr(callErr, errors.ErrorCodeMemoryOutOfBounds)
}
}
@@ -1105,7 +1041,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
output, memErr := memory.Read(offset, size)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v] (%d) 0x%X\n", offset, size, len(output), output)
return output, nil
@@ -1115,14 +1051,14 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
output, memErr := memory.Read(offset, size)
if memErr != nil {
vm.Debugf(" => Memory err: %s", memErr)
- return nil, firstErr(err, ErrMemoryOutOfBounds)
+ return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
vm.Debugf(" => [%v, %v] (%d) 0x%X\n", offset, size, len(output), output)
- return output, ErrExecutionReverted
+ return output, errors.ErrorCodeExecutionReverted
case INVALID: //0xFE
- return nil, ErrExecutionAborted
+ return nil, errors.ErrorCodeExecutionAborted
case SELFDESTRUCT: // 0xFF
addr := stack.Pop()
@@ -1134,14 +1070,14 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
return nil, firstErr(err, errAcc)
}
if receiver == nil {
- var gasErr error
+ var gasErr errors.CodedError
if useGasNegative(gas, GasCreateAccount, &gasErr) {
return nil, firstErr(err, gasErr)
}
- if !HasPermission(callState, callee, permission.CreateContract) {
- return nil, firstErr(err, ErrPermission{"create_contract"})
+ if !HasPermission(callState, callee, ptypes.CreateContract) {
+ return nil, firstErr(err, errors.PermissionDenied{Perm: ptypes.CreateContract})
}
- var createErr error
+ var createErr errors.CodedError
receiver, createErr = vm.createAccount(callState, callee, logger)
if createErr != nil {
return nil, firstErr(err, createErr)
@@ -1162,25 +1098,25 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
return nil, nil
case STATICCALL, CREATE2:
- return nil, fmt.Errorf("%s not yet implemented", op.Name())
+ return nil, errors.Errorf("%s not yet implemented", op.Name())
default:
vm.Debugf("(pc) %-3v Unknown opcode %X\n", pc, op)
- return nil, fmt.Errorf("unknown opcode %X", op)
+ return nil, errors.Errorf("unknown opcode %X", op)
}
pc++
}
}
-func (vm *VM) createAccount(callState state.Cache, callee acm.MutableAccount, logger *logging.Logger) (acm.MutableAccount, error) {
+func (vm *VM) createAccount(callState state.Cache, callee acm.MutableAccount, logger *logging.Logger) (acm.MutableAccount, errors.CodedError) {
newAccount := DeriveNewAccount(callee, state.GlobalAccountPermissions(callState), logger)
err := callState.UpdateAccount(newAccount)
if err != nil {
- return nil, err
+ return nil, errors.AsCodedError(err)
}
err = callState.UpdateAccount(callee)
if err != nil {
- return nil, err
+ return nil, errors.AsCodedError(err)
}
return newAccount, nil
}
@@ -1216,33 +1152,33 @@ func codeGetOp(code []byte, n int64) OpCode {
}
}
-func (vm *VM) jump(code []byte, to int64, pc *int64) (err error) {
+func (vm *VM) jump(code []byte, to int64, pc *int64) (err errors.CodedError) {
dest := codeGetOp(code, to)
if dest != JUMPDEST {
vm.Debugf(" ~> %v invalid jump dest %v\n", to, dest)
- return ErrInvalidJumpDest
+ return errors.ErrorCodeInvalidJumpDest
}
vm.Debugf(" ~> %v\n", to)
*pc = to
return nil
}
-func firstErr(errA, errB error) error {
+func firstErr(errA, errB error) errors.CodedError {
if errA != nil {
- return errA
+ return errors.AsCodedError(errA)
} else {
- return errB
+ return errors.AsCodedError(errB)
}
}
-func transfer(from, to acm.MutableAccount, amount uint64) error {
+func transfer(from, to acm.MutableAccount, amount uint64) errors.CodedError {
if from.Balance() < amount {
- return ErrInsufficientBalance
+ return errors.ErrorCodeInsufficientBalance
} else {
from.SubtractFromBalance(amount)
_, err := to.AddToBalance(amount)
if err != nil {
- return err
+ return errors.AsCodedError(err)
}
}
return nil
diff --git a/execution/evm/vm_test.go b/execution/evm/vm_test.go
index fcd008459d25238492445e8acf065ef7dce91b8a..b7752b66c324ece4cc1d0f97d4f497934084e3cb 100644
--- a/execution/evm/vm_test.go
+++ b/execution/evm/vm_test.go
@@ -17,7 +17,6 @@ package evm
import (
"context"
"encoding/hex"
- "errors"
"fmt"
"strconv"
"testing"
@@ -28,6 +27,7 @@ import (
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
. "github.com/hyperledger/burrow/execution/evm/asm"
. "github.com/hyperledger/burrow/execution/evm/asm/bc"
evm_events "github.com/hyperledger/burrow/execution/evm/events"
@@ -663,8 +663,8 @@ func TestRevert(t *testing.T) {
0x67, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, PUSH1, 0x00, MSTORE, PUSH1, 0x0E, PUSH1, 0x00, REVERT)*/
- output, err := ourVm.Call(cache, account1, account2, bytecode, []byte{}, 0, &gas)
- assert.Error(t, err, "Expected execution reverted error")
+ output, cErr := ourVm.Call(cache, account1, account2, bytecode, []byte{}, 0, &gas)
+ assert.Error(t, cErr, "Expected execution reverted error")
storageVal, err := cache.GetStorage(account1.Address(), LeftPadWord256(key))
assert.Equal(t, LeftPadWord256(value), storageVal)
@@ -884,7 +884,7 @@ func TestInvalid(t *testing.T) {
0x00, 0x00, 0x00, PUSH1, 0x00, MSTORE, PUSH1, 0x0E, PUSH1, 0x00, INVALID)
output, err := ourVm.Call(cache, account1, account2, bytecode, []byte{}, 0, &gas)
- expected := "call error: " + ErrExecutionAborted.Error()
+ expected := errors.ErrorCodeExecutionAborted.Error()
assert.EqualError(t, err, expected)
t.Logf("Output: %v Error: %v\n", output, err)
@@ -1021,8 +1021,8 @@ func runVMWaitError(vmCache state.Cache, ourVm *VM, caller, callee acm.MutableAc
}
select {
case eventDataCall := <-eventCh:
- if eventDataCall.Exception != "" {
- return output, errors.New(eventDataCall.Exception)
+ if eventDataCall.Exception != nil {
+ return output, eventDataCall.Exception
}
return output, nil
}
diff --git a/execution/execution.go b/execution/execution.go
index 74eab81fe51fae147219e0fbcd3bc4935a478cc7..c97fd2fbf431f1b39ad54bacb1cf8e9b57aea533 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -25,6 +25,7 @@ import (
bcm "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
"github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/execution/evm"
"github.com/hyperledger/burrow/execution/names"
@@ -235,11 +236,11 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
if exe.eventCache != nil {
for _, i := range tx.Inputs {
- events.PublishAccountInput(exe.eventCache, i.Address, txEnv.Tx, nil, "")
+ events.PublishAccountInput(exe.eventCache, i.Address, txEnv.Tx, nil, nil)
}
for _, o := range tx.Outputs {
- events.PublishAccountOutput(exe.eventCache, o.Address, txEnv.Tx, nil, "")
+ events.PublishAccountOutput(exe.eventCache, o.Address, txEnv.Tx, nil, nil)
}
}
return nil
@@ -285,7 +286,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
if !createContract {
// check if its a native contract
- if evm.RegisteredNativeContract(tx.Address.Word256()) {
+ if evm.IsRegisteredNativeContract(tx.Address.Word256()) {
return fmt.Errorf("attempt to call a native contract at %s, "+
"but native contracts cannot be called using CallTx. Use a "+
"contract that calls the native contract or the appropriate tx "+
@@ -418,13 +419,9 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
// Fire Events for sender and receiver
// a separate event will be fired from vm for each additional call
if exe.eventCache != nil {
- exception := ""
- if err != nil {
- exception = err.Error()
- }
- events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, ret, exception)
+ events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, ret, errors.AsCodedError(err))
if tx.Address != nil {
- events.PublishAccountOutput(exe.eventCache, *tx.Address, txEnv.Tx, ret, exception)
+ events.PublishAccountOutput(exe.eventCache, *tx.Address, txEnv.Tx, ret, errors.AsCodedError(err))
}
}
} else {
@@ -599,7 +596,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
// TODO: maybe we want to take funds on error and allow txs in that don't do anythingi?
if exe.eventCache != nil {
- events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, nil, "")
+ events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, nil, nil)
events.PublishNameReg(exe.eventCache, txEnv.Tx)
}
@@ -765,7 +762,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
// check permission
if !HasPermission(exe.stateCache, inAcc, permFlag, logger) {
return fmt.Errorf("account %s does not have moderator permission %s (%b)", tx.Input.Address,
- permission.PermFlagToString(permFlag), permFlag)
+ permFlag.String(), permFlag)
}
err = validateInput(inAcc, tx.Input)
@@ -783,27 +780,27 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
var permAcc acm.Account
switch tx.PermArgs.PermFlag {
- case permission.HasBase:
+ case ptypes.HasBase:
// this one doesn't make sense from txs
return fmt.Errorf("HasBase is for contracts, not humans. Just look at the blockchain")
- case permission.SetBase:
+ case ptypes.SetBase:
permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Set(*tx.PermArgs.Permission, *tx.PermArgs.Value)
})
- case permission.UnsetBase:
+ case ptypes.UnsetBase:
permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Unset(*tx.PermArgs.Permission)
})
- case permission.SetGlobal:
+ case ptypes.SetGlobal:
permAcc, err = mutatePermissions(exe.stateCache, acm.GlobalPermissionsAddress,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Set(*tx.PermArgs.Permission, *tx.PermArgs.Value)
})
- case permission.HasRole:
+ case ptypes.HasRole:
return fmt.Errorf("HasRole is for contracts, not humans. Just look at the blockchain")
- case permission.AddRole:
+ case ptypes.AddRole:
permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
if !perms.AddRole(*tx.PermArgs.Role) {
@@ -812,7 +809,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
}
return nil
})
- case permission.RemoveRole:
+ case ptypes.RemoveRole:
permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
if !perms.RmRole(*tx.PermArgs.Role) {
@@ -822,7 +819,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
return nil
})
default:
- return fmt.Errorf("invalid permission function: %s", permission.PermFlagToString(permFlag))
+ return fmt.Errorf("invalid permission function: %v", permFlag)
}
// TODO: maybe we want to take funds on error and allow txs in that don't do anythingi?
@@ -847,8 +844,8 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
}
if exe.eventCache != nil {
- events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, nil, "")
- events.PublishPermissions(exe.eventCache, permission.PermFlagToString(permFlag), txEnv.Tx)
+ events.PublishAccountInput(exe.eventCache, tx.Input.Address, txEnv.Tx, nil, nil)
+ events.PublishPermissions(exe.eventCache, permFlag, txEnv.Tx)
}
return nil
@@ -1158,32 +1155,30 @@ func adjustByOutputs(accs map[crypto.Address]acm.MutableAccount, outs []*payload
// Get permission on an account or fall back to global value
func HasPermission(accountGetter state.AccountGetter, acc acm.Account, perm ptypes.PermFlag, logger *logging.Logger) bool {
- if perm > permission.AllPermFlags {
+ if perm > ptypes.AllPermFlags {
logger.InfoMsg(
fmt.Sprintf("HasPermission called on invalid permission 0b%b (invalid) > 0b%b (maximum) ",
- perm, permission.AllPermFlags),
+ perm, ptypes.AllPermFlags),
"invalid_permission", perm,
- "maximum_permission", permission.AllPermFlags)
+ "maximum_permission", ptypes.AllPermFlags)
return false
}
- permString := permission.String(perm)
-
v, err := acc.Permissions().Base.Compose(state.GlobalAccountPermissions(accountGetter).Base).Get(perm)
if err != nil {
logger.TraceMsg("Error obtaining permission value (will default to false/deny)",
- "perm_flag", permString,
+ "perm_flag", perm.String(),
structure.ErrorKey, err)
}
if v {
logger.TraceMsg("Account has permission",
"account_address", acc.Address,
- "perm_flag", permString)
+ "perm_flag", perm.String())
} else {
logger.TraceMsg("Account does not have permission",
"account_address", acc.Address,
- "perm_flag", permString)
+ "perm_flag", perm.String())
}
return v
}
@@ -1192,7 +1187,7 @@ func HasPermission(accountGetter state.AccountGetter, acc acm.Account, perm ptyp
func hasSendPermission(accountGetter state.AccountGetter, accs map[crypto.Address]acm.MutableAccount,
logger *logging.Logger) bool {
for _, acc := range accs {
- if !HasPermission(accountGetter, acc, permission.Send, logger) {
+ if !HasPermission(accountGetter, acc, ptypes.Send, logger) {
return false
}
}
@@ -1201,23 +1196,23 @@ func hasSendPermission(accountGetter state.AccountGetter, accs map[crypto.Addres
func hasNamePermission(accountGetter state.AccountGetter, acc acm.Account,
logger *logging.Logger) bool {
- return HasPermission(accountGetter, acc, permission.Name, logger)
+ return HasPermission(accountGetter, acc, ptypes.Name, logger)
}
func hasCallPermission(accountGetter state.AccountGetter, acc acm.Account,
logger *logging.Logger) bool {
- return HasPermission(accountGetter, acc, permission.Call, logger)
+ return HasPermission(accountGetter, acc, ptypes.Call, logger)
}
func hasCreateContractPermission(accountGetter state.AccountGetter, acc acm.Account,
logger *logging.Logger) bool {
- return HasPermission(accountGetter, acc, permission.CreateContract, logger)
+ return HasPermission(accountGetter, acc, ptypes.CreateContract, logger)
}
func hasCreateAccountPermission(accountGetter state.AccountGetter, accs map[crypto.Address]acm.MutableAccount,
logger *logging.Logger) bool {
for _, acc := range accs {
- if !HasPermission(accountGetter, acc, permission.CreateAccount, logger) {
+ if !HasPermission(accountGetter, acc, ptypes.CreateAccount, logger) {
return false
}
}
@@ -1226,14 +1221,14 @@ func hasCreateAccountPermission(accountGetter state.AccountGetter, accs map[cryp
func hasBondPermission(accountGetter state.AccountGetter, acc acm.Account,
logger *logging.Logger) bool {
- return HasPermission(accountGetter, acc, permission.Bond, logger)
+ return HasPermission(accountGetter, acc, ptypes.Bond, logger)
}
func hasBondOrSendPermission(accountGetter state.AccountGetter, accs map[crypto.Address]acm.Account,
logger *logging.Logger) bool {
for _, acc := range accs {
- if !HasPermission(accountGetter, acc, permission.Bond, logger) {
- if !HasPermission(accountGetter, acc, permission.Send, logger) {
+ if !HasPermission(accountGetter, acc, ptypes.Bond, logger) {
+ if !HasPermission(accountGetter, acc, ptypes.Send, logger) {
return false
}
}
diff --git a/execution/execution_test.go b/execution/execution_test.go
index e846840971b8f741ffa2bf54a8f425161728fbd7..6a92abe455cbeeae5cb115e0c1f65afc5235995d 100644
--- a/execution/execution_test.go
+++ b/execution/execution_test.go
@@ -30,6 +30,7 @@ import (
bcm "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/errors"
exe_events "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/execution/evm"
. "github.com/hyperledger/burrow/execution/evm/asm"
@@ -187,9 +188,9 @@ func TestSendFails(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true)
- genDoc.Accounts[2].Permissions.Base.Set(permission.Call, true)
- genDoc.Accounts[3].Permissions.Base.Set(permission.CreateContract, true)
+ genDoc.Accounts[1].Permissions.Base.Set(ptypes.Send, true)
+ genDoc.Accounts[2].Permissions.Base.Set(ptypes.Call, true)
+ genDoc.Accounts[3].Permissions.Base.Set(ptypes.CreateContract, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -224,7 +225,7 @@ func TestSendFails(t *testing.T) {
// simple send tx to unknown account without create_account perm should fail
acc := getAccount(batchCommitter.stateCache, users[3].Address())
- acc.MutablePermissions().Base.Set(permission.Send, true)
+ acc.MutablePermissions().Base.Set(ptypes.Send, true)
batchCommitter.stateCache.UpdateAccount(acc)
tx = payload.NewSendTx()
if err := tx.AddInput(batchCommitter.stateCache, users[3].PublicKey(), 5); err != nil {
@@ -238,8 +239,8 @@ func TestName(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true)
- genDoc.Accounts[1].Permissions.Base.Set(permission.Name, true)
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true)
+ genDoc.Accounts[1].Permissions.Base.Set(ptypes.Name, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -266,9 +267,9 @@ func TestCallFails(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true)
- genDoc.Accounts[2].Permissions.Base.Set(permission.Call, true)
- genDoc.Accounts[3].Permissions.Base.Set(permission.CreateContract, true)
+ genDoc.Accounts[1].Permissions.Base.Set(ptypes.Send, true)
+ genDoc.Accounts[2].Permissions.Base.Set(ptypes.Call, true)
+ genDoc.Accounts[3].Permissions.Base.Set(ptypes.CreateContract, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -309,7 +310,7 @@ func TestSendPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -334,7 +335,7 @@ func TestCallPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -382,27 +383,23 @@ func TestCallPermission(t *testing.T) {
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception := execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception == "" {
- t.Fatal("Expected exception")
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.Error(t, err)
//----------------------------------------------------------
// call to contract that calls simple contract - with perm
fmt.Println("\n##### CALL TO SIMPLE CONTRACT (PASS)")
// A single input, having the permission, and the contract has permission
- caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
+ caller1Acc.MutablePermissions().Base.Set(ptypes.Call, true)
batchCommitter.stateCache.UpdateAccount(caller1Acc)
tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception != "" {
- t.Fatal("Unexpected exception:", exception)
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.NoError(t, err)
//----------------------------------------------------------
// call to contract that calls contract that calls simple contract - without perm
@@ -420,8 +417,8 @@ func TestCallPermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- caller1Acc.MutablePermissions().Base.Set(permission.Call, false)
- caller2Acc.MutablePermissions().Base.Set(permission.Call, true)
+ caller1Acc.MutablePermissions().Base.Set(ptypes.Call, false)
+ caller2Acc.MutablePermissions().Base.Set(ptypes.Call, true)
batchCommitter.stateCache.UpdateAccount(caller1Acc)
batchCommitter.stateCache.UpdateAccount(caller2Acc)
@@ -429,10 +426,8 @@ func TestCallPermission(t *testing.T) {
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception == "" {
- t.Fatal("Expected exception")
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.Error(t, err)
//----------------------------------------------------------
// call to contract that calls contract that calls simple contract - without perm
@@ -440,7 +435,7 @@ func TestCallPermission(t *testing.T) {
// both caller1 and caller2 have permission
fmt.Println("\n##### CALL TO CONTRACT CALLING SIMPLE CONTRACT (PASS)")
- caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
+ caller1Acc.MutablePermissions().Base.Set(ptypes.Call, true)
batchCommitter.stateCache.UpdateAccount(caller1Acc)
tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
@@ -448,18 +443,16 @@ func TestCallPermission(t *testing.T) {
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception != "" {
- t.Fatal("Unexpected exception", exception)
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.NoError(t, err)
}
func TestCreatePermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.CreateContract, true) // give the 0 account permission
- genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.CreateContract, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -517,16 +510,14 @@ func TestCreatePermission(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception := execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(contractAddr)) //
- if exception == "" {
- t.Fatal("expected exception")
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(contractAddr)) //
+ require.Error(t, err)
//------------------------------
// call the contract (should PASS)
fmt.Println("\n###### CALL THE FACTORY (PASS)")
- contractAcc.MutablePermissions().Base.Set(permission.CreateContract, true)
+ contractAcc.MutablePermissions().Base.Set(ptypes.CreateContract, true)
batchCommitter.stateCache.UpdateAccount(contractAcc)
// A single input, having the permission, should succeed
@@ -534,10 +525,8 @@ func TestCreatePermission(t *testing.T) {
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(contractAddr)) //
- if exception != "" {
- t.Fatal("unexpected exception", exception)
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(contractAddr)) //
+ require.NoError(t, err)
//--------------------------------
fmt.Println("\n##### CALL to empty address")
@@ -552,8 +541,8 @@ func TestCreatePermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- contractAcc.MutablePermissions().Base.Set(permission.Call, true)
- contractAcc.MutablePermissions().Base.Set(permission.CreateContract, true)
+ contractAcc.MutablePermissions().Base.Set(ptypes.Call, true)
+ contractAcc.MutablePermissions().Base.Set(ptypes.CreateContract, true)
batchCommitter.stateCache.UpdateAccount(contractAcc)
// this should call the 0 address but not create ...
@@ -561,10 +550,8 @@ func TestCreatePermission(t *testing.T) {
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(crypto.Address{})) //
- if exception != "" {
- t.Fatal("unexpected exception", exception)
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(crypto.Address{})) //
+ require.NoError(t, err)
zeroAcc := getAccount(batchCommitter.stateCache, crypto.Address{})
if len(zeroAcc.Code()) != 0 {
t.Fatal("the zero account was given code from a CALL!")
@@ -575,9 +562,9 @@ func TestCreateAccountPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
- genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
- genDoc.Accounts[0].Permissions.Base.Set(permission.CreateAccount, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true) // give the 0 account permission
+ genDoc.Accounts[1].Permissions.Base.Set(ptypes.Send, true) // give the 0 account permission
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.CreateAccount, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
batchCommitter := makeExecutor(st)
@@ -618,7 +605,7 @@ func TestCreateAccountPermission(t *testing.T) {
// Two inputs, both with send, both with create, should pass
acc := getAccount(batchCommitter.stateCache, users[1].Address())
- acc.MutablePermissions().Base.Set(permission.CreateAccount, true)
+ acc.MutablePermissions().Base.Set(ptypes.CreateAccount, true)
batchCommitter.stateCache.UpdateAccount(acc)
tx = payload.NewSendTx()
if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
@@ -646,7 +633,7 @@ func TestCreateAccountPermission(t *testing.T) {
// CALL to unknown account
acc = getAccount(batchCommitter.stateCache, users[0].Address())
- acc.MutablePermissions().Base.Set(permission.Call, true)
+ acc.MutablePermissions().Base.Set(ptypes.Call, true)
batchCommitter.stateCache.UpdateAccount(acc)
// call to contract that calls unknown account - without create_account perm
@@ -669,15 +656,13 @@ func TestCreateAccountPermission(t *testing.T) {
txCallEnv.Sign(users[0])
// we need to subscribe to the Call event to detect the exception
- _, exception := execTxWaitEvent(t, batchCommitter, txCallEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception == "" {
- t.Fatal("Expected exception")
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txCallEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.Error(t, err)
// NOTE: for a contract to be able to CreateAccount, it must be able to call
// NOTE: for a users to be able to CreateAccount, it must be able to send!
- caller1Acc.MutablePermissions().Base.Set(permission.CreateAccount, true)
- caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
+ caller1Acc.MutablePermissions().Base.Set(ptypes.CreateAccount, true)
+ caller1Acc.MutablePermissions().Base.Set(ptypes.Call, true)
batchCommitter.stateCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
txCall, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
@@ -685,10 +670,8 @@ func TestCreateAccountPermission(t *testing.T) {
txCallEnv.Sign(users[0])
// we need to subscribe to the Call event to detect the exception
- _, exception = execTxWaitEvent(t, batchCommitter, txCallEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
- if exception != "" {
- t.Fatal("Unexpected exception", exception)
- }
+ _, err = execTxWaitEvent(t, batchCommitter, txCallEnv, evm_events.EventStringAccountCall(caller1ContractAddr)) //
+ require.NoError(t, err)
}
@@ -703,8 +686,8 @@ func TestSNativeCALL(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
- genDoc.Accounts[3].Permissions.Base.Set(permission.Bond, true) // some arbitrary permission to play with
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
+ genDoc.Accounts[3].Permissions.Base.Set(ptypes.Bond, true) // some arbitrary permission to play with
genDoc.Accounts[3].Permissions.AddRole("bumble")
genDoc.Accounts[3].Permissions.AddRole("bee")
st, err := MakeGenesisState(stateDB, &genDoc)
@@ -724,13 +707,13 @@ func TestSNativeCALL(t *testing.T) {
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- doug.MutablePermissions().Base.Set(permission.Call, true)
+ doug.MutablePermissions().Base.Set(ptypes.Call, true)
//doug.Permissions.Base.Set(permission.HasBase, true)
batchCommitter.stateCache.UpdateAccount(doug)
fmt.Println("\n#### HasBase")
// HasBase
- snativeAddress, pF, data := snativePermTestInputCALL("hasBase", users[3], permission.Bond, false)
+ snativeAddress, pF, data := snativePermTestInputCALL("hasBase", users[3], ptypes.Bond, false)
testSNativeCALLExpectFail(t, batchCommitter, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
@@ -742,10 +725,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### SetBase")
// SetBase
- snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], permission.Bond, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], ptypes.Bond, false)
testSNativeCALLExpectFail(t, batchCommitter, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
- snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], permission.Bond, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.Bond, false)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret) {
@@ -753,9 +736,9 @@ func TestSNativeCALL(t *testing.T) {
}
return nil
})
- snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], permission.CreateContract, true)
+ snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], ptypes.CreateContract, true)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
- snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], permission.CreateContract, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
@@ -766,10 +749,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### UnsetBase")
// UnsetBase
- snativeAddress, pF, data = snativePermTestInputCALL("unsetBase", users[3], permission.CreateContract, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("unsetBase", users[3], ptypes.CreateContract, false)
testSNativeCALLExpectFail(t, batchCommitter, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
- snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], permission.CreateContract, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
@@ -779,10 +762,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### SetGlobal")
// SetGlobalPerm
- snativeAddress, pF, data = snativePermTestInputCALL("setGlobal", users[3], permission.CreateContract, true)
+ snativeAddress, pF, data = snativePermTestInputCALL("setGlobal", users[3], ptypes.CreateContract, true)
testSNativeCALLExpectFail(t, batchCommitter, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
- snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], permission.CreateContract, false)
+ snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, batchCommitter, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
@@ -840,8 +823,8 @@ func TestSNativeTx(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
- genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
- genDoc.Accounts[3].Permissions.Base.Set(permission.Bond, true) // some arbitrary permission to play with
+ genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
+ genDoc.Accounts[3].Permissions.Base.Set(ptypes.Bond, true) // some arbitrary permission to play with
genDoc.Accounts[3].Permissions.AddRole("bumble")
genDoc.Accounts[3].Permissions.AddRole("bee")
st, err := MakeGenesisState(stateDB, &genDoc)
@@ -853,37 +836,37 @@ func TestSNativeTx(t *testing.T) {
fmt.Println("\n#### SetBase")
// SetBase
- snativeArgs := snativePermTestInputTx("setBase", users[3], permission.Bond, false)
+ snativeArgs := snativePermTestInputTx("setBase", users[3], ptypes.Bond, false)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
- testSNativeTxExpectPass(t, batchCommitter, permission.SetBase, snativeArgs)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.SetBase, snativeArgs)
acc := getAccount(batchCommitter.stateCache, users[3].Address())
- if v, _ := acc.MutablePermissions().Base.Get(permission.Bond); v {
+ if v, _ := acc.MutablePermissions().Base.Get(ptypes.Bond); v {
t.Fatal("expected permission to be set false")
}
- snativeArgs = snativePermTestInputTx("setBase", users[3], permission.CreateContract, true)
- testSNativeTxExpectPass(t, batchCommitter, permission.SetBase, snativeArgs)
+ snativeArgs = snativePermTestInputTx("setBase", users[3], ptypes.CreateContract, true)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.SetBase, snativeArgs)
acc = getAccount(batchCommitter.stateCache, users[3].Address())
- if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); !v {
+ if v, _ := acc.MutablePermissions().Base.Get(ptypes.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
fmt.Println("\n#### UnsetBase")
// UnsetBase
- snativeArgs = snativePermTestInputTx("unsetBase", users[3], permission.CreateContract, false)
+ snativeArgs = snativePermTestInputTx("unsetBase", users[3], ptypes.CreateContract, false)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
- testSNativeTxExpectPass(t, batchCommitter, permission.UnsetBase, snativeArgs)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.UnsetBase, snativeArgs)
acc = getAccount(batchCommitter.stateCache, users[3].Address())
- if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); v {
+ if v, _ := acc.MutablePermissions().Base.Get(ptypes.CreateContract); v {
t.Fatal("expected permission to be set false")
}
fmt.Println("\n#### SetGlobal")
// SetGlobalPerm
- snativeArgs = snativePermTestInputTx("setGlobal", users[3], permission.CreateContract, true)
+ snativeArgs = snativePermTestInputTx("setGlobal", users[3], ptypes.CreateContract, true)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
- testSNativeTxExpectPass(t, batchCommitter, permission.SetGlobal, snativeArgs)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.SetGlobal, snativeArgs)
acc = getAccount(batchCommitter.stateCache, acm.GlobalPermissionsAddress)
- if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); !v {
+ if v, _ := acc.MutablePermissions().Base.Get(ptypes.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
@@ -891,7 +874,7 @@ func TestSNativeTx(t *testing.T) {
// AddRole
snativeArgs = snativeRoleTestInputTx("addRole", users[3], "chuck")
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
- testSNativeTxExpectPass(t, batchCommitter, permission.AddRole, snativeArgs)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.AddRole, snativeArgs)
acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v := acc.Permissions().HasRole("chuck"); !v {
t.Fatal("expected role to be added")
@@ -901,7 +884,7 @@ func TestSNativeTx(t *testing.T) {
// RemoveRole
snativeArgs = snativeRoleTestInputTx("removeRole", users[3], "chuck")
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
- testSNativeTxExpectPass(t, batchCommitter, permission.RemoveRole, snativeArgs)
+ testSNativeTxExpectPass(t, batchCommitter, ptypes.RemoveRole, snativeArgs)
acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v := acc.Permissions().HasRole("chuck"); v {
t.Fatal("expected role to be removed")
@@ -1671,11 +1654,11 @@ func addressPtr(account acm.Account) *crypto.Address {
//-------------------------------------------------------------------------------------
// helpers
-var ExceptionTimeOut = "timed out waiting for event"
+var ExceptionTimeOut = errors.NewCodedError(errors.ErrorCodeGeneric, "timed out waiting for event")
// run ExecTx and wait for the Call event on given addr
// returns the msg data and an error/exception
-func execTxWaitEvent(t *testing.T, batchCommitter *executor, txEnv *txs.Envelope, eventid string) (interface{}, string) {
+func execTxWaitEvent(t *testing.T, batchCommitter *executor, txEnv *txs.Envelope, eventid string) (interface{}, error) {
emitter := event.NewEmitter(logger)
ch := make(chan interface{})
emitter.Subscribe(context.Background(), "test", event.QueryForEventID(eventid), ch)
@@ -1683,7 +1666,7 @@ func execTxWaitEvent(t *testing.T, batchCommitter *executor, txEnv *txs.Envelope
batchCommitter.eventCache = evc
go func() {
if err := batchCommitter.Execute(txEnv); err != nil {
- ch <- err.Error()
+ ch <- err
}
evc.Flush()
}()
@@ -1693,13 +1676,19 @@ func execTxWaitEvent(t *testing.T, batchCommitter *executor, txEnv *txs.Envelope
case msg := <-ch:
switch ev := msg.(type) {
case *exe_events.EventDataTx:
- return ev, ev.Exception
+ if ev.Exception != nil {
+ return nil, ev.Exception
+ }
+ return ev, nil
case *evm_events.EventDataCall:
- return ev, ev.Exception
- case string:
+ if ev.Exception != nil {
+ return nil, ev.Exception
+ }
+ return ev, nil
+ case error:
return nil, ev
default:
- return ev, ""
+ return ev, nil
}
case <-ticker.C:
return nil, ExceptionTimeOut
@@ -1733,23 +1722,19 @@ func testSNativeCALL(t *testing.T, expectPass bool, batchCommitter *executor, do
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
t.Logf("subscribing to %v", evm_events.EventStringAccountCall(snativeAddress))
- ev, exception := execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(snativeAddress))
- if exception == ExceptionTimeOut {
+ ev, err := execTxWaitEvent(t, batchCommitter, txEnv, evm_events.EventStringAccountCall(snativeAddress))
+ if err == ExceptionTimeOut {
t.Fatal("Timed out waiting for event")
}
if expectPass {
- if exception != "" {
- t.Fatal("Unexpected exception", exception)
- }
+ require.NoError(t, err)
evv := ev.(*evm_events.EventDataCall)
ret := evv.Return
if err := f(ret); err != nil {
t.Fatal(err)
}
} else {
- if exception == "" {
- t.Fatal("Expected exception")
- }
+ require.Error(t, err)
}
}
@@ -1820,7 +1805,7 @@ func snativePermTestInputCALL(name string, user acm.AddressableSigner, perm ptyp
}
data = append(permNameToFuncID(name), data...)
var err error
- if pF, err = permission.PermStringToFlag(name); err != nil {
+ if pF, err = ptypes.PermStringToFlag(name); err != nil {
panic(fmt.Sprintf("failed to convert perm string (%s) to flag", name))
}
return
@@ -1850,7 +1835,7 @@ func snativeRoleTestInputCALL(name string, user acm.AddressableSigner,
data = append(permNameToFuncID(name), data...)
var err error
- if pF, err = permission.PermStringToFlag(name); err != nil {
+ if pF, err = ptypes.PermStringToFlag(name); err != nil {
panic(fmt.Sprintf("failed to convert perm string (%s) to flag", name))
}
return
diff --git a/execution/state.go b/execution/state.go
index 7ccc79196f5d61145ff22a9286e351ec05a9963b..da8ce2053d3da3a004de37e70616b9b089edb3a5 100644
--- a/execution/state.go
+++ b/execution/state.go
@@ -28,7 +28,8 @@ import (
"github.com/hyperledger/burrow/execution/names"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging"
- ptypes "github.com/hyperledger/burrow/permission"
+ "github.com/hyperledger/burrow/permission"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/tendermint/go-wire"
"github.com/tendermint/iavl"
dbm "github.com/tendermint/tmlibs/db"
@@ -106,7 +107,7 @@ func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)
// global permissions are saved as the 0 address
// so they are included in the accounts tree
- globalPerms := ptypes.DefaultAccountPermissions
+ globalPerms := permission.DefaultAccountPermissions
globalPerms = genesisDoc.GlobalPermissions
// XXX: make sure the set bits are all true
// Without it the HasPermission() functions will fail
diff --git a/execution/state_test.go b/execution/state_test.go
index 6ad9c32192ec5efc1cec705138a5ef83f2cb400d..e72076b1359f6d07294c123a2a36b6637fd32278 100644
--- a/execution/state_test.go
+++ b/execution/state_test.go
@@ -18,7 +18,7 @@ import (
"testing"
acm "github.com/hyperledger/burrow/account"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/tmlibs/db"
diff --git a/execution/transactor.go b/execution/transactor.go
index bc0c9b9c69bc05bef889d5066da099d8002128f7..2a855dc329ad2cbb552b0dedcdfc5f73146bacbc 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -71,7 +71,7 @@ func NewTransactor(tip *blockchain.Tip, eventEmitter event.Emitter,
func (trans *Transactor) Call(reader state.Reader, fromAddress, toAddress crypto.Address,
data []byte) (call *Call, err error) {
- if evm.RegisteredNativeContract(toAddress.Word256()) {
+ if evm.IsRegisteredNativeContract(toAddress.Word256()) {
return nil, fmt.Errorf("attempt to call native contract at address "+
"%X, but native contracts can not be called directly. Use a deployed "+
"contract that calls the native function instead", toAddress)
@@ -235,8 +235,8 @@ func (trans *Transactor) TransactAndHold(sequentialSigningAccount *SequentialSig
case <-timer.C:
return nil, fmt.Errorf("transaction timed out TxHash: %X", expectedReceipt.TxHash)
case eventDataCall := <-ch:
- if eventDataCall.Exception != "" {
- return nil, fmt.Errorf("error when transacting: " + eventDataCall.Exception)
+ if eventDataCall.Exception != nil {
+ return nil, fmt.Errorf("error when transacting: %v", eventDataCall.Exception)
} else {
return eventDataCall, nil
}
diff --git a/genesis/spec/genesis_spec_test.go b/genesis/spec/genesis_spec_test.go
index ca91146fb71be6356ffd55abd31cec4590fc0b0b..6ce214dc434fda5299990847385feb9cb110a513 100644
--- a/genesis/spec/genesis_spec_test.go
+++ b/genesis/spec/genesis_spec_test.go
@@ -5,7 +5,7 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/keys/mock"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
diff --git a/genesis/spec/presets.go b/genesis/spec/presets.go
index 312ec7a79a78888f687210a56e218c32ad16a4e4..9454520c9f284666349d8b2334c59879e1c169d0 100644
--- a/genesis/spec/presets.go
+++ b/genesis/spec/presets.go
@@ -3,7 +3,7 @@ package spec
import (
"sort"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
)
// Files here can be used as starting points for building various 'chain types' but are otherwise
diff --git a/genesis/spec/presets_test.go b/genesis/spec/presets_test.go
index 8e578640e8790aab8923006e7ec8d864a3cec5b5..dde6f296c7103fa5ca33dcaf0416aa797c440265 100644
--- a/genesis/spec/presets_test.go
+++ b/genesis/spec/presets_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/hyperledger/burrow/keys/mock"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
diff --git a/permission/permissions.go b/permission/permissions.go
index 5bfcf61c9205c1a6ae222e8110298759c8cd8a9a..48b5bd9dd3bd2e11353993c8ce96964017a8a75a 100644
--- a/permission/permissions.go
+++ b/permission/permissions.go
@@ -15,82 +15,9 @@
package permission
import (
- "fmt"
- "strings"
-
"github.com/hyperledger/burrow/permission/types"
)
-//------------------------------------------------------------------------------------------------
-
-// Base permission references are like unix (the index is already bit shifted)
-const (
- // Chain permissions.
- // These permissions grant the ability for accounts to perform certain transition within the execution package
- // Root is a reserved permission currently unused that may be used in the future to grant super-user privileges
- // for instance to a governance contract
- Root types.PermFlag = 1 << iota // 1
- // Send permits an account to issue a SendTx to transfer value from one account to another. Note that value can
- // still be transferred with a CallTx by specifying an Amount in the InputTx. Funding an account is the basic
- // prerequisite for an account to act in the system so is often used as a surrogate for 'account creation' when
- // sending to a unknown account - in order for this to be permitted the input account needs the CreateAccount
- // permission in addition.
- Send // 2
- // Call permits and account to issue a CallTx, which can be used to call (run) the code of an existing
- // account/contract (these are synonymous in Burrow/EVM). A CallTx can be used to create an account if it points to
- // a nil address - in order for an account to be permitted to do this the input (calling) account needs the
- // CreateContract permission in addition.
- Call // 4
- // CreateContract permits the input account of a CallTx to create a new contract/account when CallTx.Address is nil
- // and permits an executing contract in the EVM to create a new contract programmatically.
- CreateContract // 8
- // CreateAccount permits an input account of a SendTx to add value to non-existing (unfunded) accounts
- CreateAccount // 16
- // Bond is a reserved permission for making changes to the validator set - currently unused
- Bond // 32
- // Name permits manipulation of the name registry by allowing an account to issue a NameTx
- Name // 64
-
- // Moderator permissions.
- // These permissions concern the alteration of the chain permissions listed above. Each permission relates to a
- // particular canonical permission mutation or query function. When an account is granted a moderation permission
- // it is permitted to call that function. See snative.go for a marked-up description of what each function does.
- HasBase
- SetBase
- UnsetBase
- SetGlobal
- HasRole
- AddRole
- RemoveRole
-
- NumPermissions uint = 14 // NOTE Adjust this too. We can support upto 64
-
- TopPermFlag types.PermFlag = 1 << (NumPermissions - 1)
- AllPermFlags types.PermFlag = TopPermFlag | (TopPermFlag - 1)
- DefaultPermFlags types.PermFlag = Send | Call | CreateContract | CreateAccount | Bond | Name | HasBase | HasRole
-
- // Chain permissions strings
- RootString string = "root"
- SendString = "send"
- CallString = "call"
- CreateContractString = "createContract"
- CreateAccountString = "createAccount"
- BondString = "bond"
- NameString = "name"
-
- // Moderator permissions strings
- HasBaseString = "hasBase"
- SetBaseString = "setBase"
- UnsetBaseString = "unsetBase"
- SetGlobalString = "setGlobal"
- HasRoleString = "hasRole"
- AddRoleString = "addRole"
- RemoveRoleString = "removeRole"
- UnknownString = "#-UNKNOWN-#"
-
- AllString = "all"
-)
-
var (
ZeroBasePermissions = types.BasePermissions{0, 0}
ZeroAccountPermissions = types.AccountPermissions{
@@ -98,99 +25,16 @@ var (
}
DefaultAccountPermissions = types.AccountPermissions{
Base: types.BasePermissions{
- Perms: DefaultPermFlags,
- SetBit: AllPermFlags,
+ Perms: types.DefaultPermFlags,
+ SetBit: types.AllPermFlags,
},
Roles: []string{},
}
AllAccountPermissions = types.AccountPermissions{
Base: types.BasePermissions{
- Perms: AllPermFlags,
- SetBit: AllPermFlags,
+ Perms: types.AllPermFlags,
+ SetBit: types.AllPermFlags,
},
Roles: []string{},
}
)
-
-//---------------------------------------------------------------------------------------------
-
-//--------------------------------------------------------------------------------
-// string utilities
-
-// Returns the string name of a single bit non-composite PermFlag, or otherwise UnknownString
-// See BasePermissionsToStringList to generate a string representation of a composite PermFlag
-func PermFlagToString(pf types.PermFlag) string {
- switch pf {
- case AllPermFlags:
- return AllString
- case Root:
- return RootString
- case Send:
- return SendString
- case Call:
- return CallString
- case CreateContract:
- return CreateContractString
- case CreateAccount:
- return CreateAccountString
- case Bond:
- return BondString
- case Name:
- return NameString
- case HasBase:
- return HasBaseString
- case SetBase:
- return SetBaseString
- case UnsetBase:
- return UnsetBaseString
- case SetGlobal:
- return SetGlobalString
- case HasRole:
- return HasRoleString
- case AddRole:
- return AddRoleString
- case RemoveRole:
- return RemoveRoleString
- default:
- return UnknownString
- }
-}
-
-// PermStringToFlag maps camel- and snake case strings to the
-// the corresponding permission flag.
-func PermStringToFlag(perm string) (types.PermFlag, error) {
- switch strings.ToLower(perm) {
- case AllString:
- return AllPermFlags, nil
- case RootString:
- return Root, nil
- case SendString:
- return Send, nil
- case CallString:
- return Call, nil
- case CreateContractString, "createcontract", "create_contract":
- return CreateContract, nil
- case CreateAccountString, "createaccount", "create_account":
- return CreateAccount, nil
- case BondString:
- return Bond, nil
- case NameString:
- return Name, nil
- case HasBaseString, "hasbase", "has_base":
- return HasBase, nil
- case SetBaseString, "setbase", "set_base":
- return SetBase, nil
- case UnsetBaseString, "unsetbase", "unset_base":
- return UnsetBase, nil
- case SetGlobalString, "setglobal", "set_global":
- return SetGlobal, nil
- case HasRoleString, "hasrole", "has_role":
- return HasRole, nil
- case AddRoleString, "addrole", "add_role":
- return AddRole, nil
- case RemoveRoleString, "removerole", "rmrole", "rm_role":
- return RemoveRole, nil
- default:
- return 0, fmt.Errorf("unknown permission %s", perm)
- }
-}
diff --git a/permission/snatives/snatives.go b/permission/snatives/snatives.go
index 40e560ea9087903b220e5eaec49a82a3721ce352..5b47b8af5e894c0b9f5cdf6e26947db2ad398c35 100644
--- a/permission/snatives/snatives.go
+++ b/permission/snatives/snatives.go
@@ -21,6 +21,7 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/permission"
"github.com/hyperledger/burrow/permission/types"
+ ptypes "github.com/hyperledger/burrow/permission/types"
)
//---------------------------------------------------------------------------------------------------
@@ -36,12 +37,12 @@ type PermArgs struct {
func (pa PermArgs) String() string {
body := make([]string, 0, 5)
- body = append(body, fmt.Sprintf("PermFlag: %s", permission.String(pa.PermFlag)))
+ body = append(body, fmt.Sprintf("PermFlag: %v", permission.String(pa.PermFlag)))
if pa.Address != nil {
body = append(body, fmt.Sprintf("Address: %s", *pa.Address))
}
if pa.Permission != nil {
- body = append(body, fmt.Sprintf("Permission: %s", permission.String(*pa.Permission)))
+ body = append(body, fmt.Sprintf("Permission: %v", permission.String(*pa.Permission)))
}
if pa.Role != nil {
body = append(body, fmt.Sprintf("Role: %s", *pa.Role))
@@ -55,10 +56,10 @@ func (pa PermArgs) String() string {
func (pa PermArgs) EnsureValid() error {
pf := pa.PermFlag
// Address
- if pa.Address == nil && pf != permission.SetGlobal {
+ if pa.Address == nil && pf != ptypes.SetGlobal {
return fmt.Errorf("PermArgs for PermFlag %v requires Address to be provided but was nil", pf)
}
- if pf == permission.HasRole || pf == permission.AddRole || pf == permission.RemoveRole {
+ if pf == ptypes.HasRole || pf == ptypes.AddRole || pf == ptypes.RemoveRole {
// Role
if pa.Role == nil {
return fmt.Errorf("PermArgs for PermFlag %v requires Role to be provided but was nil", pf)
@@ -67,7 +68,7 @@ func (pa PermArgs) EnsureValid() error {
} else if pa.Permission == nil {
return fmt.Errorf("PermArgs for PermFlag %v requires Permission to be provided but was nil", pf)
// Value
- } else if (pf == permission.SetBase || pf == permission.SetGlobal) && pa.Value == nil {
+ } else if (pf == ptypes.SetBase || pf == ptypes.SetGlobal) && pa.Value == nil {
return fmt.Errorf("PermArgs for PermFlag %v requires Value to be provided but was nil", pf)
}
return nil
@@ -75,7 +76,7 @@ func (pa PermArgs) EnsureValid() error {
func HasBaseArgs(address crypto.Address, permFlag types.PermFlag) PermArgs {
return PermArgs{
- PermFlag: permission.HasBase,
+ PermFlag: ptypes.HasBase,
Address: &address,
Permission: &permFlag,
}
@@ -83,7 +84,7 @@ func HasBaseArgs(address crypto.Address, permFlag types.PermFlag) PermArgs {
func SetBaseArgs(address crypto.Address, permFlag types.PermFlag, value bool) PermArgs {
return PermArgs{
- PermFlag: permission.SetBase,
+ PermFlag: ptypes.SetBase,
Address: &address,
Permission: &permFlag,
Value: &value,
@@ -92,7 +93,7 @@ func SetBaseArgs(address crypto.Address, permFlag types.PermFlag, value bool) Pe
func UnsetBaseArgs(address crypto.Address, permFlag types.PermFlag) PermArgs {
return PermArgs{
- PermFlag: permission.UnsetBase,
+ PermFlag: ptypes.UnsetBase,
Address: &address,
Permission: &permFlag,
}
@@ -100,7 +101,7 @@ func UnsetBaseArgs(address crypto.Address, permFlag types.PermFlag) PermArgs {
func SetGlobalArgs(permFlag types.PermFlag, value bool) PermArgs {
return PermArgs{
- PermFlag: permission.SetGlobal,
+ PermFlag: ptypes.SetGlobal,
Permission: &permFlag,
Value: &value,
}
@@ -108,7 +109,7 @@ func SetGlobalArgs(permFlag types.PermFlag, value bool) PermArgs {
func HasRoleArgs(address crypto.Address, role string) PermArgs {
return PermArgs{
- PermFlag: permission.HasRole,
+ PermFlag: ptypes.HasRole,
Address: &address,
Role: &role,
}
@@ -116,7 +117,7 @@ func HasRoleArgs(address crypto.Address, role string) PermArgs {
func AddRoleArgs(address crypto.Address, role string) PermArgs {
return PermArgs{
- PermFlag: permission.AddRole,
+ PermFlag: ptypes.AddRole,
Address: &address,
Role: &role,
}
@@ -124,7 +125,7 @@ func AddRoleArgs(address crypto.Address, role string) PermArgs {
func RemoveRoleArgs(address crypto.Address, role string) PermArgs {
return PermArgs{
- PermFlag: permission.RemoveRole,
+ PermFlag: ptypes.RemoveRole,
Address: &address,
Role: &role,
}
diff --git a/permission/snatives/snatives_test.go b/permission/snatives/snatives_test.go
index 76545151df366826e1f24deb5a6f100af8e48b2d..9441ed15eaccc20c7391e3ce4452ec01933ecb4a 100644
--- a/permission/snatives/snatives_test.go
+++ b/permission/snatives/snatives_test.go
@@ -3,7 +3,7 @@ package snatives
import (
"testing"
- "github.com/hyperledger/burrow/permission"
+ permission "github.com/hyperledger/burrow/permission/types"
"github.com/stretchr/testify/assert"
)
diff --git a/permission/types/base_permissions.go b/permission/types/base_permissions.go
index fe0dd5e32abe7f1db5dd33cb1906a784e3f8129a..401f46d1225a4589311cfa8472ce52310bbd576c 100644
--- a/permission/types/base_permissions.go
+++ b/permission/types/base_permissions.go
@@ -2,24 +2,6 @@ package types
import "fmt"
-// A particular permission
-type PermFlag uint64
-
-// permission number out of bounds
-type ErrInvalidPermission PermFlag
-
-func (e ErrInvalidPermission) Error() string {
- return fmt.Sprintf("invalid permission %d", e)
-}
-
-// set=false. This error should be caught and the global
-// value fetched for the permission by the caller
-type ErrValueNotSet PermFlag
-
-func (e ErrValueNotSet) Error() string {
- return fmt.Sprintf("the value for permission %d is not set", e)
-}
-
// Base chain permissions struct
type BasePermissions struct {
// bit array with "has"/"doesn't have" for each permission
diff --git a/permission/errors.go b/permission/types/errors.go
similarity index 59%
rename from permission/errors.go
rename to permission/types/errors.go
index 795b621cac31d5a52159c6a16bafa24ce4106e68..0b022277e9352561b2fe83a655f750c6a146d21f 100644
--- a/permission/errors.go
+++ b/permission/types/errors.go
@@ -12,7 +12,22 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package permission
+package types
-//------------------------------------------------------------------------------------------------
-// Some errors
+import (
+ "fmt"
+)
+
+type ErrInvalidPermission PermFlag
+
+func (e ErrInvalidPermission) Error() string {
+ return fmt.Sprintf("invalid permission %d", e)
+}
+
+// set=false. This error should be caught and the global
+// value fetched for the permission by the caller
+type ErrValueNotSet PermFlag
+
+func (e ErrValueNotSet) Error() string {
+ return fmt.Sprintf("the value for permission %d is not set", e)
+}
diff --git a/permission/types/perm_flag.go b/permission/types/perm_flag.go
new file mode 100644
index 0000000000000000000000000000000000000000..c749aa308b6f3e1b292b0e30cefc4a4030958b24
--- /dev/null
+++ b/permission/types/perm_flag.go
@@ -0,0 +1,155 @@
+package types
+
+import (
+ "fmt"
+ "strings"
+)
+
+// Base permission references are like unix (the index is already bit shifted)
+const (
+ // Chain permissions.
+ // These permissions grant the ability for accounts to perform certain transition within the execution package
+ // Root is a reserved permission currently unused that may be used in the future to grant super-user privileges
+ // for instance to a governance contract
+ Root PermFlag = 1 << iota // 1
+ // Send permits an account to issue a SendTx to transfer value from one account to another. Note that value can
+ // still be transferred with a CallTx by specifying an Amount in the InputTx. Funding an account is the basic
+ // prerequisite for an account to act in the system so is often used as a surrogate for 'account creation' when
+ // sending to a unknown account - in order for this to be permitted the input account needs the CreateAccount
+ // permission in addition.
+ Send // 2
+ // Call permits and account to issue a CallTx, which can be used to call (run) the code of an existing
+ // account/contract (these are synonymous in Burrow/EVM). A CallTx can be used to create an account if it points to
+ // a nil address - in order for an account to be permitted to do this the input (calling) account needs the
+ // CreateContract permission in addition.
+ Call // 4
+ // CreateContract permits the input account of a CallTx to create a new contract/account when CallTx.Address is nil
+ // and permits an executing contract in the EVM to create a new contract programmatically.
+ CreateContract // 8
+ // CreateAccount permits an input account of a SendTx to add value to non-existing (unfunded) accounts
+ CreateAccount // 16
+ // Bond is a reserved permission for making changes to the validator set - currently unused
+ Bond // 32
+ // Name permits manipulation of the name registry by allowing an account to issue a NameTx
+ Name // 64
+
+ // Moderator permissions.
+ // These permissions concern the alteration of the chain permissions listed above. Each permission relates to a
+ // particular canonical permission mutation or query function. When an account is granted a moderation permission
+ // it is permitted to call that function. See snative.go for a marked-up description of what each function does.
+ HasBase
+ SetBase
+ UnsetBase
+ SetGlobal
+ HasRole
+ AddRole
+ RemoveRole
+
+ NumPermissions uint = 14 // NOTE Adjust this too. We can support upto 64
+
+ TopPermFlag PermFlag = 1 << (NumPermissions - 1)
+ AllPermFlags PermFlag = TopPermFlag | (TopPermFlag - 1)
+ DefaultPermFlags PermFlag = Send | Call | CreateContract | CreateAccount | Bond | Name | HasBase | HasRole
+
+ // Chain permissions strings
+ RootString string = "root"
+ SendString = "send"
+ CallString = "call"
+ CreateContractString = "createContract"
+ CreateAccountString = "createAccount"
+ BondString = "bond"
+ NameString = "name"
+
+ // Moderator permissions strings
+ HasBaseString = "hasBase"
+ SetBaseString = "setBase"
+ UnsetBaseString = "unsetBase"
+ SetGlobalString = "setGlobal"
+ HasRoleString = "hasRole"
+ AddRoleString = "addRole"
+ RemoveRoleString = "removeRole"
+ UnknownString = "#-UNKNOWN-#"
+
+ AllString = "all"
+)
+
+// A particular permission
+type PermFlag uint64
+
+// Returns the string name of a single bit non-composite PermFlag, or otherwise UnknownString
+// See BasePermissionsToStringList to generate a string representation of a composite PermFlag
+func (pf PermFlag) String() string {
+ switch pf {
+ case AllPermFlags:
+ return AllString
+ case Root:
+ return RootString
+ case Send:
+ return SendString
+ case Call:
+ return CallString
+ case CreateContract:
+ return CreateContractString
+ case CreateAccount:
+ return CreateAccountString
+ case Bond:
+ return BondString
+ case Name:
+ return NameString
+ case HasBase:
+ return HasBaseString
+ case SetBase:
+ return SetBaseString
+ case UnsetBase:
+ return UnsetBaseString
+ case SetGlobal:
+ return SetGlobalString
+ case HasRole:
+ return HasRoleString
+ case AddRole:
+ return AddRoleString
+ case RemoveRole:
+ return RemoveRoleString
+ default:
+ return UnknownString
+ }
+}
+
+// PermStringToFlag maps camel- and snake case strings to the
+// the corresponding permission flag.
+func PermStringToFlag(perm string) (PermFlag, error) {
+ switch strings.ToLower(perm) {
+ case AllString:
+ return AllPermFlags, nil
+ case RootString:
+ return Root, nil
+ case SendString:
+ return Send, nil
+ case CallString:
+ return Call, nil
+ case CreateContractString, "createcontract", "create_contract":
+ return CreateContract, nil
+ case CreateAccountString, "createaccount", "create_account":
+ return CreateAccount, nil
+ case BondString:
+ return Bond, nil
+ case NameString:
+ return Name, nil
+ case HasBaseString, "hasbase", "has_base":
+ return HasBase, nil
+ case SetBaseString, "setbase", "set_base":
+ return SetBase, nil
+ case UnsetBaseString, "unsetbase", "unset_base":
+ return UnsetBase, nil
+ case SetGlobalString, "setglobal", "set_global":
+ return SetGlobal, nil
+ case HasRoleString, "hasrole", "has_role":
+ return HasRole, nil
+ case AddRoleString, "addrole", "add_role":
+ return AddRole, nil
+ case RemoveRoleString, "removerole", "rmrole", "rm_role":
+ return RemoveRole, nil
+ default:
+ return 0, fmt.Errorf("unknown permission %s", perm)
+ }
+}
diff --git a/permission/permissions_test.go b/permission/types/perm_flag_test.go
similarity index 91%
rename from permission/permissions_test.go
rename to permission/types/perm_flag_test.go
index 5d930a7c703809a04adbf4cfe2512249b1490481..2ec7a6edb257f51ff897cc7d29151df051706e3a 100644
--- a/permission/permissions_test.go
+++ b/permission/types/perm_flag_test.go
@@ -1,4 +1,4 @@
-package permission
+package types
import (
"testing"
diff --git a/permission/util.go b/permission/util.go
index 656761cd83030127313ede68c528ffe8973b00cd..7470b94d90b27ee48b04cf40b67b215c8370f4c2 100644
--- a/permission/util.go
+++ b/permission/util.go
@@ -45,7 +45,7 @@ func convertPermissionsMapStringIntToBasePermissions(permissions map[string]bool
basePermissions := ZeroBasePermissions
for permissionName, value := range permissions {
- permissionsFlag, err := PermStringToFlag(permissionName)
+ permissionsFlag, err := types.PermStringToFlag(permissionName)
if err != nil {
return basePermissions, err
}
@@ -74,7 +74,7 @@ func BasePermissionsFromStringList(permissions []string) (types.BasePermissions,
func PermFlagFromStringList(permissions []string) (types.PermFlag, error) {
var permFlag types.PermFlag
for _, perm := range permissions {
- flag, err := PermStringToFlag(perm)
+ flag, err := types.PermStringToFlag(perm)
if err != nil {
return permFlag, err
}
@@ -92,15 +92,15 @@ func BasePermissionsToStringList(basePermissions types.BasePermissions) ([]strin
// Creates a list of individual permission flag strings from a possibly composite PermFlag
// by projecting out each bit and adding its permission string if it is set
func PermFlagToStringList(permFlag types.PermFlag) ([]string, error) {
- permStrings := make([]string, 0, NumPermissions)
- if permFlag > AllPermFlags {
+ permStrings := make([]string, 0, types.NumPermissions)
+ if permFlag > types.AllPermFlags {
return nil, fmt.Errorf("resultant permission 0b%b is invalid: has permission flag set above top flag 0b%b",
- permFlag, TopPermFlag)
+ permFlag, types.TopPermFlag)
}
- for i := uint(0); i < NumPermissions; i++ {
+ for i := uint(0); i < types.NumPermissions; i++ {
permFlag := permFlag & (1 << i)
if permFlag > 0 {
- permStrings = append(permStrings, PermFlagToString(permFlag))
+ permStrings = append(permStrings, permFlag.String())
}
}
return permStrings, nil
@@ -110,7 +110,7 @@ func PermFlagToStringList(permFlag types.PermFlag) ([]string, error) {
func BasePermissionsString(basePermissions types.BasePermissions) string {
permStrings, err := BasePermissionsToStringList(basePermissions)
if err != nil {
- return UnknownString
+ return types.UnknownString
}
return strings.Join(permStrings, " | ")
}
@@ -118,7 +118,7 @@ func BasePermissionsString(basePermissions types.BasePermissions) string {
func String(permFlag types.PermFlag) string {
permStrings, err := PermFlagToStringList(permFlag)
if err != nil {
- return UnknownString
+ return types.UnknownString
}
return strings.Join(permStrings, " | ")
}
diff --git a/permission/util_test.go b/permission/util_test.go
index 4d1c806b1073c39c83bc7a6d1a18f85a1117dfb6..780c1651cb91900798536133288d0a8cdfeed134 100644
--- a/permission/util_test.go
+++ b/permission/util_test.go
@@ -9,15 +9,15 @@ import (
)
func TestBasePermissionsFromStringList(t *testing.T) {
- basePerms, err := BasePermissionsFromStringList([]string{HasRoleString, CreateContractString, SendString})
+ basePerms, err := BasePermissionsFromStringList([]string{types.HasRoleString, types.CreateContractString, types.SendString})
require.NoError(t, err)
- permFlag := HasRole | CreateContract | Send
+ permFlag := types.HasRole | types.CreateContract | types.Send
assert.Equal(t, permFlag, basePerms.Perms)
assert.Equal(t, permFlag, basePerms.SetBit)
- basePerms, err = BasePermissionsFromStringList([]string{AllString})
+ basePerms, err = BasePermissionsFromStringList([]string{types.AllString})
require.NoError(t, err)
- permFlag = AllPermFlags
+ permFlag = types.AllPermFlags
assert.Equal(t, permFlag, basePerms.Perms)
assert.Equal(t, permFlag, basePerms.SetBit)
@@ -26,21 +26,21 @@ func TestBasePermissionsFromStringList(t *testing.T) {
}
func TestBasePermissionsToStringList(t *testing.T) {
- permStrings, err := BasePermissionsToStringList(allSetBasePermission(Root | HasRole | SetBase | Call))
+ permStrings, err := BasePermissionsToStringList(allSetBasePermission(types.Root | types.HasRole | types.SetBase | types.Call))
require.NoError(t, err)
assert.Equal(t, []string{"root", "call", "setBase", "hasRole"}, permStrings)
- permStrings, err = BasePermissionsToStringList(allSetBasePermission(AllPermFlags))
+ permStrings, err = BasePermissionsToStringList(allSetBasePermission(types.AllPermFlags))
require.NoError(t, err)
assert.Equal(t, []string{"root", "send", "call", "createContract", "createAccount", "bond", "name", "hasBase",
"setBase", "unsetBase", "setGlobal", "hasRole", "addRole", "removeRole"}, permStrings)
- permStrings, err = BasePermissionsToStringList(allSetBasePermission(AllPermFlags + 1))
+ permStrings, err = BasePermissionsToStringList(allSetBasePermission(types.AllPermFlags + 1))
assert.Error(t, err)
}
func TestBasePermissionsString(t *testing.T) {
- permissionString := BasePermissionsString(allSetBasePermission(AllPermFlags &^ Root))
+ permissionString := BasePermissionsString(allSetBasePermission(types.AllPermFlags &^ types.Root))
assert.Equal(t, "send | call | createContract | createAccount | bond | name | hasBase | "+
"setBase | unsetBase | setGlobal | hasRole | addRole | removeRole", permissionString)
}
diff --git a/txs/tx_test.go b/txs/tx_test.go
index ada6bcd607b1964a943ae5fccb90f306afe69644..bb916e86ab3a144dfaf9d170d1a195a8b7ac01ed 100644
--- a/txs/tx_test.go
+++ b/txs/tx_test.go
@@ -21,8 +21,8 @@ import (
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/crypto"
- ptypes "github.com/hyperledger/burrow/permission"
"github.com/hyperledger/burrow/permission/snatives"
+ ptypes "github.com/hyperledger/burrow/permission/types"
"github.com/hyperledger/burrow/txs/payload"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"