func TestSendPermission(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true) // give the 0 account permission
st := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
// A single input, having the permission, should succeed
tx := types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[0])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Transaction failed", err)
}
// Two inputs, one with permission, one without, should fail
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[2].Address, 10)
tx.SignInput(chainID, 0, user[0])
tx.SignInput(chainID, 1, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
}
func cliRestore(cmd *cobra.Command, args []string) {
if len(args) != 1 {
Exit(fmt.Errorf("Enter the chain id"))
}
chainID := args[0]
var err error
var b []byte
if IPFShash == "" {
fi, _ := os.Stdin.Stat()
if fi.Size() == 0 {
Exit(fmt.Errorf("Please pass data to restore on Stdin or specify IPFS hash with --ipfs=\"[hash]\""))
}
b, err = ioutil.ReadAll(os.Stdin)
IfExit(err)
} else {
url := composeIPFSUrl(HostFlag, ApiFlag)
w := bytes.NewBuffer([]byte{})
w.Write([]byte("Reading file from IPFS. Hash =>\t" + IPFShash + "\n"))
b, err = IPFSCat(url, IPFShash, ApiFlag, w)
IfExit(err)
}
CoreRestore(chainID, b)
stateDB := dbm.GetDB("state")
newState := sm.LoadState(stateDB)
fmt.Printf("State hash: %X\n", newState.Hash())
}
func TestName(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true)
genDoc.Accounts[1].Permissions.Base.Set(ptypes.Name, true)
st := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//-------------------
// name txs
// simple name tx without perm should fail
tx, err := types.NewNameTx(st, user[0].PubKey, "somename", "somedata", 10000, 100)
if err != nil {
t.Fatal(err)
}
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple name tx with perm should pass
tx, err = types.NewNameTx(st, user[1].PubKey, "somename", "somedata", 10000, 100)
if err != nil {
t.Fatal(err)
}
tx.Sign(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal(err)
}
}
func TestRestoreDump(t *testing.T) {
b1, err := ioutil.ReadFile(path.Join(TestDir, "data1.json")) // with validators
if err != nil {
t.Fatal(err)
}
b2, err := ioutil.ReadFile(path.Join(TestDir, "data2.json")) // without
if err != nil {
t.Fatal(err)
}
b1 = bytes.Trim(b1, "\n")
b2 = bytes.Trim(b2, "\n")
// restore to a memdir
config.Set("db_backend", "memdb")
cfg.ApplyConfig(config) // Notify modules of new config
CoreRestore("", b1)
stateDB := dbm.GetDB("state")
st := sm.LoadState(stateDB)
acc := st.GetAccount(ptypes.GlobalPermissionsAddress)
fmt.Println(acc)
dump1 := CoreDump(true) // with validators
if bytes.Compare(b1, dump1) != 0 {
ld, lb := len(dump1), len(b1)
max := int(math.Max(float64(ld), float64(lb)))
n := 100
for i := 0; i < max/n; i++ {
dd := dump1[i*n : (i+1)*n]
bb := b1[i*n : (i+1)*n]
if bytes.Compare(dd, bb) != 0 {
t.Fatalf("Error in dumps! Got \n\n\n\n %s \n\n\n\n Expected \n\n\n\n %s", dd, bb)
}
}
}
CoreRestore("", b2)
dump2 := CoreDump(false) //without validators
if bytes.Compare(b2, dump2) != 0 {
ld, lb := len(dump2), len(b2)
max := int(math.Max(float64(ld), float64(lb)))
n := 100
for i := 0; i < max/n; i++ {
dd := dump2[i*n : (i+1)*n]
bb := b2[i*n : (i+1)*n]
if bytes.Compare(dd, bb) != 0 {
t.Fatalf("Error in dumps! Got \n\n\n\n %s \n\n\n\n Expected \n\n\n\n %s", dd, bb)
}
}
}
}
// restore state from json blob
// set tendermint config before calling
func CoreRestore(chainID string, jsonBytes []byte) {
var stJ State
var err error
wire.ReadJSON(&stJ, jsonBytes, &err)
IfExit(err)
st := new(sm.State)
st.ChainID = chainID
st.BondedValidators = stJ.BondedValidators
st.LastBondedValidators = stJ.LastBondedValidators
st.UnbondingValidators = stJ.UnbondingValidators
stateDB := dbm.GetDB("state")
// fill the accounts tree
accounts := merkle.NewIAVLTree(wire.BasicCodec, acm.AccountCodec, 1000, stateDB)
for _, account := range stJ.Accounts {
accounts.Set(account.Address, account.Copy())
}
// fill the storage tree for each contract
for _, accStorage := range stJ.AccountsStorage {
st := merkle.NewIAVLTree(wire.BasicCodec, wire.BasicCodec, 1024, stateDB)
for _, accSt := range accStorage.Storage {
set := st.Set(accSt.Key, accSt.Value)
if !set {
panic("failed to update storage tree")
}
}
// TODO: sanity check vs acc.StorageRoot
st.Save()
}
valInfos := merkle.NewIAVLTree(wire.BasicCodec, types.ValidatorInfoCodec, 0, stateDB)
for _, valInfo := range stJ.ValidatorInfos {
valInfos.Set(valInfo.Address, valInfo)
}
nameReg := merkle.NewIAVLTree(wire.BasicCodec, sm.NameRegCodec, 0, stateDB)
for _, entry := range stJ.NameReg {
nameReg.Set(entry.Name, entry)
}
// persists accounts/valInfos/nameReg trees
st.SetAccounts(accounts)
st.SetValidatorInfos(valInfos)
st.SetNameReg(nameReg)
st.SetDB(stateDB)
st.Save()
}
// dump the latest state to json
func CoreDump(dumpval bool) []byte {
// Get State
stateDB := dbm.GetDB("state")
st := sm.LoadState(stateDB)
if st == nil {
Exit(fmt.Errorf("Error: state loaded from %s is nil!", config.GetString("db_dir")))
}
stJ := new(State)
//default is true, flag omits vals from dump
if dumpval {
stJ.BondedValidators = st.BondedValidators
stJ.LastBondedValidators = st.LastBondedValidators
stJ.UnbondingValidators = st.UnbondingValidators
}
// iterate through accounts tree
// track storage roots as we go
storageRoots := [][]byte{}
st.GetAccounts().Iterate(func(key interface{}, value interface{}) (stopped bool) {
acc := value.(*acm.Account)
stJ.Accounts = append(stJ.Accounts, acc)
storageRoots = append(storageRoots, acc.StorageRoot)
return false
})
// grab all storage
for i, root := range storageRoots {
if len(root) == 0 {
continue
}
accStorage := &AccountStorage{Address: stJ.Accounts[i].Address}
storage := merkle.NewIAVLTree(wire.BasicCodec, wire.BasicCodec, 1024, stateDB)
storage.Load(root)
storage.Iterate(func(key interface{}, value interface{}) (stopped bool) {
k, v := key.([]byte), value.([]byte)
accStorage.Storage = append(accStorage.Storage, &Storage{k, v})
return false
})
stJ.AccountsStorage = append(stJ.AccountsStorage, accStorage)
}
// get all validator infos
if dumpval {
st.GetValidatorInfos().Iterate(func(key interface{}, value interface{}) (stopped bool) {
vi := value.(*types.ValidatorInfo)
stJ.ValidatorInfos = append(stJ.ValidatorInfos, vi)
return false
})
}
// get all name entries
st.GetNames().Iterate(func(key interface{}, value interface{}) (stopped bool) {
name := value.(*types.NameRegEntry)
stJ.NameReg = append(stJ.NameReg, name)
return false
})
w, n, err := new(bytes.Buffer), new(int64), new(error)
wire.WriteJSON(stJ, w, n, err)
IfExit(*err)
w2 := new(bytes.Buffer)
json.Indent(w2, w.Bytes(), "", "\t")
return w2.Bytes()
}
func TestSNativeTx(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//----------------------------------------------------------
// Test SNativeTx
fmt.Println("\n#### SetBase")
// SetBase
snativeArgs := snativePermTestInputTx("set_base", user[3], ptypes.Bond, false)
testSNativeTxExpectFail(t, blockCache, snativeArgs)
testSNativeTxExpectPass(t, blockCache, ptypes.SetBase, snativeArgs)
acc := blockCache.GetAccount(user[3].Address)
if v, _ := acc.Permissions.Base.Get(ptypes.Bond); v {
t.Fatal("expected permission to be set false")
}
snativeArgs = snativePermTestInputTx("set_base", user[3], ptypes.CreateContract, true)
testSNativeTxExpectPass(t, blockCache, ptypes.SetBase, snativeArgs)
acc = blockCache.GetAccount(user[3].Address)
if v, _ := acc.Permissions.Base.Get(ptypes.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
fmt.Println("\n#### UnsetBase")
// UnsetBase
snativeArgs = snativePermTestInputTx("unset_base", user[3], ptypes.CreateContract, false)
testSNativeTxExpectFail(t, blockCache, snativeArgs)
testSNativeTxExpectPass(t, blockCache, ptypes.UnsetBase, snativeArgs)
acc = blockCache.GetAccount(user[3].Address)
if v, _ := acc.Permissions.Base.Get(ptypes.CreateContract); v {
t.Fatal("expected permission to be set false")
}
fmt.Println("\n#### SetGlobal")
// SetGlobalPerm
snativeArgs = snativePermTestInputTx("set_global", user[3], ptypes.CreateContract, true)
testSNativeTxExpectFail(t, blockCache, snativeArgs)
testSNativeTxExpectPass(t, blockCache, ptypes.SetGlobal, snativeArgs)
acc = blockCache.GetAccount(ptypes.GlobalPermissionsAddress)
if v, _ := acc.Permissions.Base.Get(ptypes.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
fmt.Println("\n#### AddRole")
// AddRole
snativeArgs = snativeRoleTestInputTx("add_role", user[3], "chuck")
testSNativeTxExpectFail(t, blockCache, snativeArgs)
testSNativeTxExpectPass(t, blockCache, ptypes.AddRole, snativeArgs)
acc = blockCache.GetAccount(user[3].Address)
if v := acc.Permissions.HasRole("chuck"); !v {
t.Fatal("expected role to be added")
}
fmt.Println("\n#### RmRole")
// RmRole
snativeArgs = snativeRoleTestInputTx("rm_role", user[3], "chuck")
testSNativeTxExpectFail(t, blockCache, snativeArgs)
testSNativeTxExpectPass(t, blockCache, ptypes.RmRole, snativeArgs)
acc = blockCache.GetAccount(user[3].Address)
if v := acc.Permissions.HasRole("chuck"); v {
t.Fatal("expected role to be removed")
}
}
func TestSNativeCALL(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//----------------------------------------------------------
// Test CALL to SNative contracts
// make the main contract once
doug := &acm.Account{
Address: DougAddress,
Balance: 0,
Code: nil,
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
doug.Permissions.Base.Set(ptypes.Call, true)
//doug.Permissions.Base.Set(ptypes.HasBase, true)
blockCache.UpdateAccount(doug)
fmt.Println("\n#### HasBase")
// HasBase
snativeAddress, data := snativePermTestInputCALL("has_base", user[3], ptypes.Bond, false)
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, 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) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
return nil
})
fmt.Println("\n#### SetBase")
// SetBase
snativeAddress, data = snativePermTestInputCALL("set_base", user[3], ptypes.Bond, false)
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativePermTestInputCALL("has_base", user[3], ptypes.Bond, false)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
return nil
})
snativeAddress, data = snativePermTestInputCALL("set_base", user[3], ptypes.CreateContract, true)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativePermTestInputCALL("has_base", user[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, blockCache, doug, 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) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
return nil
})
fmt.Println("\n#### UnsetBase")
// UnsetBase
snativeAddress, data = snativePermTestInputCALL("unset_base", user[3], ptypes.CreateContract, false)
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativePermTestInputCALL("has_base", user[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
return nil
})
fmt.Println("\n#### SetGlobal")
// SetGlobalPerm
snativeAddress, data = snativePermTestInputCALL("set_global", user[3], ptypes.CreateContract, true)
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativePermTestInputCALL("has_base", user[3], ptypes.CreateContract, false)
testSNativeCALLExpectPass(t, blockCache, doug, 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) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
return nil
})
fmt.Println("\n#### HasRole")
// HasRole
snativeAddress, data = snativeRoleTestInputCALL("has_role", user[3], "bumble")
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
return nil
})
fmt.Println("\n#### AddRole")
// AddRole
snativeAddress, data = snativeRoleTestInputCALL("has_role", user[3], "chuck")
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
return nil
})
snativeAddress, data = snativeRoleTestInputCALL("add_role", user[3], "chuck")
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativeRoleTestInputCALL("has_role", user[3], "chuck")
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
return nil
})
fmt.Println("\n#### RmRole")
// RmRole
snativeAddress, data = snativeRoleTestInputCALL("rm_role", user[3], "chuck")
testSNativeCALLExpectFail(t, blockCache, doug, snativeAddress, data)
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, data = snativeRoleTestInputCALL("has_role", user[3], "chuck")
testSNativeCALLExpectPass(t, blockCache, doug, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
return nil
})
}
func TestCreateAccountPermission(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//----------------------------------------------------------
// SendTx to unknown account
// A single input, having the permission, should succeed
tx := types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[6].Address, 5)
tx.SignInput(chainID, 0, user[0])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Transaction failed", err)
}
// Two inputs, both with send, one with create, one without, should fail
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[7].Address, 10)
tx.SignInput(chainID, 0, user[0])
tx.SignInput(chainID, 1, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// Two inputs, both with send, one with create, one without, two ouputs (one known, one unknown) should fail
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[7].Address, 4)
tx.AddOutput(user[4].Address, 6)
tx.SignInput(chainID, 0, user[0])
tx.SignInput(chainID, 1, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// Two inputs, both with send, both with create, should pass
acc := blockCache.GetAccount(user[1].Address)
acc.Permissions.Base.Set(ptypes.CreateAccount, true)
blockCache.UpdateAccount(acc)
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[7].Address, 10)
tx.SignInput(chainID, 0, user[0])
tx.SignInput(chainID, 1, user[1])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Unexpected error", err)
}
// Two inputs, both with send, both with create, two outputs (one known, one unknown) should pass
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[7].Address, 7)
tx.AddOutput(user[4].Address, 3)
tx.SignInput(chainID, 0, user[0])
tx.SignInput(chainID, 1, user[1])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Unexpected error", err)
}
//----------------------------------------------------------
// CALL to unknown account
acc = blockCache.GetAccount(user[0].Address)
acc.Permissions.Base.Set(ptypes.Call, true)
blockCache.UpdateAccount(acc)
// call to contract that calls unknown account - without create_account perm
// create contract that calls the simple contract
contractCode := callContractCode(user[9].Address)
caller1ContractAddr := NewContractAddress(user[4].Address, 101)
caller1Acc := &acm.Account{
Address: caller1ContractAddr,
Balance: 0,
Code: contractCode,
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
blockCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
txCall, _ := types.NewCallTx(blockCache, user[0].PubKey, caller1ContractAddr, nil, 100, 10000, 100)
txCall.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception := execTxWaitEvent(t, blockCache, txCall, types.EventStringAccCall(caller1ContractAddr)) //
if exception == "" {
t.Fatal("Expected exception")
}
// NOTE: for a contract to be able to CreateAccount, it must be able to call
// NOTE: for a user to be able to CreateAccount, it must be able to send!
caller1Acc.Permissions.Base.Set(ptypes.CreateAccount, true)
caller1Acc.Permissions.Base.Set(ptypes.Call, true)
blockCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
txCall, _ = types.NewCallTx(blockCache, user[0].PubKey, caller1ContractAddr, nil, 100, 10000, 100)
txCall.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, txCall, types.EventStringAccCall(caller1ContractAddr)) //
if exception != "" {
t.Fatal("Unexpected exception", exception)
}
}
func TestBondPermission(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
st := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
var bondAcc *acm.Account
//------------------------------
// one bonder without permission should fail
tx, _ := types.NewBondTx(user[1].PubKey)
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[1])
tx.SignBond(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
//------------------------------
// one bonder with permission should pass
bondAcc = blockCache.GetAccount(user[1].Address)
bondAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(bondAcc)
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Unexpected error", err)
}
// reset state (we can only bond with an account once ..)
genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
st = MakeGenesisState(stateDB, &genDoc)
blockCache = NewBlockCache(st)
bondAcc = blockCache.GetAccount(user[1].Address)
bondAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(bondAcc)
//------------------------------
// one bonder with permission and an input without send should fail
tx, _ = types.NewBondTx(user[1].PubKey)
if err := tx.AddInput(blockCache, user[2].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[2])
tx.SignBond(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// reset state (we can only bond with an account once ..)
genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
st = MakeGenesisState(stateDB, &genDoc)
blockCache = NewBlockCache(st)
bondAcc = blockCache.GetAccount(user[1].Address)
bondAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(bondAcc)
//------------------------------
// one bonder with permission and an input with send should pass
sendAcc := blockCache.GetAccount(user[2].Address)
sendAcc.Permissions.Base.Set(ptypes.Send, true)
blockCache.UpdateAccount(sendAcc)
tx, _ = types.NewBondTx(user[1].PubKey)
if err := tx.AddInput(blockCache, user[2].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[2])
tx.SignBond(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Unexpected error", err)
}
// reset state (we can only bond with an account once ..)
genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
st = MakeGenesisState(stateDB, &genDoc)
blockCache = NewBlockCache(st)
bondAcc = blockCache.GetAccount(user[1].Address)
bondAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(bondAcc)
//------------------------------
// one bonder with permission and an input with bond should pass
sendAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(sendAcc)
tx, _ = types.NewBondTx(user[1].PubKey)
if err := tx.AddInput(blockCache, user[2].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[2])
tx.SignBond(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Unexpected error", err)
}
// reset state (we can only bond with an account once ..)
genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
st = MakeGenesisState(stateDB, &genDoc)
blockCache = NewBlockCache(st)
bondAcc = blockCache.GetAccount(user[1].Address)
bondAcc.Permissions.Base.Set(ptypes.Bond, true)
blockCache.UpdateAccount(bondAcc)
//------------------------------
// one bonder with permission and an input from that bonder and an input without send or bond should fail
tx, _ = types.NewBondTx(user[1].PubKey)
if err := tx.AddInput(blockCache, user[1].PubKey, 5); err != nil {
t.Fatal(err)
}
if err := tx.AddInput(blockCache, user[2].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[1])
tx.SignInput(chainID, 1, user[2])
tx.SignBond(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
}
}
func TestCreatePermission(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//------------------------------
// create a simple contract
fmt.Println("\n##### CREATE SIMPLE CONTRACT")
contractCode := []byte{0x60}
createCode := wrapContractForCreate(contractCode)
// A single input, having the permission, should succeed
tx, _ := types.NewCallTx(blockCache, user[0].PubKey, nil, createCode, 100, 100, 100)
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Transaction failed", err)
}
// ensure the contract is there
contractAddr := NewContractAddress(tx.Input.Address, tx.Input.Sequence)
contractAcc := blockCache.GetAccount(contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %X", contractAddr)
}
if bytes.Compare(contractAcc.Code, contractCode) != 0 {
t.Fatalf("contract does not have correct code. Got %X, expected %X", contractAcc.Code, contractCode)
}
//------------------------------
// create contract that uses the CREATE op
fmt.Println("\n##### CREATE FACTORY")
contractCode = []byte{0x60}
createCode = wrapContractForCreate(contractCode)
factoryCode := createContractCode()
createFactoryCode := wrapContractForCreate(factoryCode)
// A single input, having the permission, should succeed
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, nil, createFactoryCode, 100, 100, 100)
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Transaction failed", err)
}
// ensure the contract is there
contractAddr = NewContractAddress(tx.Input.Address, tx.Input.Sequence)
contractAcc = blockCache.GetAccount(contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %X", contractAddr)
}
if bytes.Compare(contractAcc.Code, factoryCode) != 0 {
t.Fatalf("contract does not have correct code. Got %X, expected %X", contractAcc.Code, factoryCode)
}
//------------------------------
// call the contract (should FAIL)
fmt.Println("\n###### CALL THE FACTORY (FAIL)")
// A single input, having the permission, should succeed
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, contractAddr, createCode, 100, 100, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception := execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(contractAddr)) //
if exception == "" {
t.Fatal("expected exception")
}
//------------------------------
// call the contract (should PASS)
fmt.Println("\n###### CALL THE FACTORY (PASS)")
contractAcc.Permissions.Base.Set(ptypes.CreateContract, true)
blockCache.UpdateAccount(contractAcc)
// A single input, having the permission, should succeed
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, contractAddr, createCode, 100, 100, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(contractAddr)) //
if exception != "" {
t.Fatal("unexpected exception", exception)
}
//--------------------------------
fmt.Println("\n##### CALL to empty address")
zeroAddr := LeftPadBytes([]byte{}, 20)
code := callContractCode(zeroAddr)
contractAddr = NewContractAddress(user[0].Address, 110)
contractAcc = &acm.Account{
Address: contractAddr,
Balance: 1000,
Code: code,
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
contractAcc.Permissions.Base.Set(ptypes.Call, true)
contractAcc.Permissions.Base.Set(ptypes.CreateContract, true)
blockCache.UpdateAccount(contractAcc)
// this should call the 0 address but not create ...
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, contractAddr, createCode, 100, 10000, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(zeroAddr)) //
if exception != "" {
t.Fatal("unexpected exception", exception)
}
zeroAcc := blockCache.GetAccount(zeroAddr)
if len(zeroAcc.Code) != 0 {
t.Fatal("the zero account was given code from a CALL!")
}
}
func TestCallPermission(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
st := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//------------------------------
// call to simple contract
fmt.Println("\n##### SIMPLE CONTRACT")
// create simple contract
simpleContractAddr := NewContractAddress(user[0].Address, 100)
simpleAcc := &acm.Account{
Address: simpleContractAddr,
Balance: 0,
Code: []byte{0x60},
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
st.UpdateAccount(simpleAcc)
// A single input, having the permission, should succeed
tx, _ := types.NewCallTx(blockCache, user[0].PubKey, simpleContractAddr, nil, 100, 100, 100)
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err != nil {
t.Fatal("Transaction failed", err)
}
//----------------------------------------------------------
// call to contract that calls simple contract - without perm
fmt.Println("\n##### CALL TO SIMPLE CONTRACT (FAIL)")
// create contract that calls the simple contract
contractCode := callContractCode(simpleContractAddr)
caller1ContractAddr := NewContractAddress(user[0].Address, 101)
caller1Acc := &acm.Account{
Address: caller1ContractAddr,
Balance: 10000,
Code: contractCode,
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
blockCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, caller1ContractAddr, nil, 100, 10000, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception := execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(caller1ContractAddr)) //
if exception == "" {
t.Fatal("Expected exception")
}
//----------------------------------------------------------
// 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.Permissions.Base.Set(ptypes.Call, true)
blockCache.UpdateAccount(caller1Acc)
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, caller1ContractAddr, nil, 100, 10000, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(caller1ContractAddr)) //
if exception != "" {
t.Fatal("Unexpected exception:", exception)
}
//----------------------------------------------------------
// call to contract that calls contract that calls simple contract - without perm
// caller1Contract calls simpleContract. caller2Contract calls caller1Contract.
// caller1Contract does not have call perms, but caller2Contract does.
fmt.Println("\n##### CALL TO CONTRACT CALLING SIMPLE CONTRACT (FAIL)")
contractCode2 := callContractCode(caller1ContractAddr)
caller2ContractAddr := NewContractAddress(user[0].Address, 102)
caller2Acc := &acm.Account{
Address: caller2ContractAddr,
Balance: 1000,
Code: contractCode2,
Sequence: 0,
StorageRoot: Zero256.Bytes(),
Permissions: ptypes.ZeroAccountPermissions,
}
caller1Acc.Permissions.Base.Set(ptypes.Call, false)
caller2Acc.Permissions.Base.Set(ptypes.Call, true)
blockCache.UpdateAccount(caller1Acc)
blockCache.UpdateAccount(caller2Acc)
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, caller2ContractAddr, nil, 100, 10000, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(caller1ContractAddr)) //
if exception == "" {
t.Fatal("Expected exception")
}
//----------------------------------------------------------
// call to contract that calls contract that calls simple contract - without perm
// caller1Contract calls simpleContract. caller2Contract calls caller1Contract.
// both caller1 and caller2 have permission
fmt.Println("\n##### CALL TO CONTRACT CALLING SIMPLE CONTRACT (PASS)")
caller1Acc.Permissions.Base.Set(ptypes.Call, true)
blockCache.UpdateAccount(caller1Acc)
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, caller2ContractAddr, nil, 100, 10000, 100)
tx.Sign(chainID, user[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, blockCache, tx, types.EventStringAccCall(caller1ContractAddr)) //
if exception != "" {
t.Fatal("Unexpected exception", exception)
}
}
func TestCallFails(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//-------------------
// call txs
// simple call tx should fail
tx, _ := types.NewCallTx(blockCache, user[0].PubKey, user[4].Address, nil, 100, 100, 100)
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple call tx with send permission should fail
tx, _ = types.NewCallTx(blockCache, user[1].PubKey, user[4].Address, nil, 100, 100, 100)
tx.Sign(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple call tx with create permission should fail
tx, _ = types.NewCallTx(blockCache, user[3].PubKey, user[4].Address, nil, 100, 100, 100)
tx.Sign(chainID, user[3])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
//-------------------
// create txs
// simple call create tx should fail
tx, _ = types.NewCallTx(blockCache, user[0].PubKey, nil, nil, 100, 100, 100)
tx.Sign(chainID, user[0])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple call create tx with send perm should fail
tx, _ = types.NewCallTx(blockCache, user[1].PubKey, nil, nil, 100, 100, 100)
tx.Sign(chainID, user[1])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple call create tx with call perm should fail
tx, _ = types.NewCallTx(blockCache, user[2].PubKey, nil, nil, 100, 100, 100)
tx.Sign(chainID, user[2])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
}
func TestSendFails(t *testing.T) {
stateDB := dbm.GetDB("state")
genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
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 := MakeGenesisState(stateDB, &genDoc)
blockCache := NewBlockCache(st)
//-------------------
// send txs
// simple send tx should fail
tx := types.NewSendTx()
if err := tx.AddInput(blockCache, user[0].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[1].Address, 5)
tx.SignInput(chainID, 0, user[0])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple send tx with call perm should fail
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[2].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[4].Address, 5)
tx.SignInput(chainID, 0, user[2])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple send tx with create perm should fail
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[3].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[4].Address, 5)
tx.SignInput(chainID, 0, user[3])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
// simple send tx to unknown account without create_account perm should fail
acc := blockCache.GetAccount(user[3].Address)
acc.Permissions.Base.Set(ptypes.Send, true)
blockCache.UpdateAccount(acc)
tx = types.NewSendTx()
if err := tx.AddInput(blockCache, user[3].PubKey, 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(user[6].Address, 5)
tx.SignInput(chainID, 0, user[3])
if err := ExecTx(blockCache, tx, true, nil); err == nil {
t.Fatal("Expected error")
} else {
fmt.Println(err)
}
}