forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 10:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

contracts: limit modification allowed time range

Browse source
This commit is contained in:
rjl493456442 2018-06-13 11:14:36 +08:00
parent a387151976
commit ca478b2dd2
3 changed files with 57 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
contracts/registrar/contract/registrar.go
View file

File diff suppressed because one or more lines are too long

11
contracts/registrar/contract/registrar.sol
View file

@ -103,7 +103,11 @@ contract Registrar {
return false; return false;
} }
// Ensure the checkpoint is stable enough to be registered. // Ensure the checkpoint is stable enough to be registered.
if (block.number < (_sectionIndex+1)*sectionSize+confirmations) { if (block.number < (_sectionIndex+1)*sectionSize+processConfirmations) {
return false;
}
// Ensure the modification for registered checkpoint within the allowed time range
if (latest != 0 && _sectionIndex == latest && block.number >= (_sectionIndex+1)*sectionSize+confirmations) {
return false; return false;
} }
@ -205,6 +209,9 @@ contract Registrar {
// The number of confirmations needed before a checkpoint can be registered. // The number of confirmations needed before a checkpoint can be registered.
// We have to make sure the checkpoint registered will not be invalid due to // We have to make sure the checkpoint registered will not be invalid due to
// chain reorg. // chain reorg.
uint constant confirmations = 256; uint constant processConfirmations = 256;
// The number of confirmations when a registered checkpoint can not be modified.
uint constant confirmations = 8192;
} }

65
contracts/registrar/registrar_test.go
View file

@ -37,13 +37,8 @@ var (
addr = crypto.PubkeyToAddress(key.PublicKey) addr = crypto.PubkeyToAddress(key.PublicKey)
emptyHash = [32]byte{} emptyHash = [32]byte{}
trustedCheckpoint = light.TrustedCheckpoint{ checkpointHash0 = crypto.Keccak256Hash(common.Hex2Bytes("dead0"), common.Hex2Bytes("beef0"), common.Hex2Bytes("deadbeef0"))
SectionIdx: 0, checkpointHash1 = crypto.Keccak256Hash(common.Hex2Bytes("dead1"), common.Hex2Bytes("beef1"), common.Hex2Bytes("deadbeef1"))
SectionHead: common.HexToHash("14c8639dfc32812ed20839f5a11993cd59b22e5226cb2179640ba5c1f0c08f87"),
ChtRoot: common.HexToHash("cf92fd2a79464354e8dae4d589ae92acdf90a3a4f8f7d8a3ec5fb9c114ae81cd"),
BloomTrieRoot: common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
}
checkpointHash = crypto.Keccak256Hash(trustedCheckpoint.SectionHead.Bytes(), trustedCheckpoint.ChtRoot.Bytes(), trustedCheckpoint.BloomTrieRoot.Bytes())
) )
// validateOperation executes the operation, watches and delivers all events fired by the backend and ensures the // validateOperation executes the operation, watches and delivers all events fired by the backend and ensures the
@ -201,9 +196,9 @@ func TestCheckpointRegister(t *testing.T) {
// Register unstable checkpoint // Register unstable checkpoint
validateOperation(t, c, contractBackend, func() { validateOperation(t, c, contractBackend, func() {
c.SetCheckpoint(transactOpts, big.NewInt(int64(trustedCheckpoint.SectionIdx)), checkpointHash) c.SetCheckpoint(transactOpts, big.NewInt(0), checkpointHash0)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error { }, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(int64(trustedCheckpoint.SectionIdx))) hash, err := c.GetCheckpoint(nil, big.NewInt(0))
if err != nil { if err != nil {
return errors.New("get checkpoint failed") return errors.New("get checkpoint failed")
} }
@ -219,9 +214,9 @@ func TestCheckpointRegister(t *testing.T) {
validateOperation(t, c, contractBackend, func() { validateOperation(t, c, contractBackend, func() {
user2, _ := crypto.GenerateKey() user2, _ := crypto.GenerateKey()
unauthorized := bind.NewKeyedTransactor(user2) unauthorized := bind.NewKeyedTransactor(user2)
c.SetCheckpoint(unauthorized, big.NewInt(int64(trustedCheckpoint.SectionIdx)), checkpointHash) c.SetCheckpoint(unauthorized, big.NewInt(0), checkpointHash0)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error { }, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(int64(trustedCheckpoint.SectionIdx))) hash, err := c.GetCheckpoint(nil, big.NewInt(0))
if err != nil { if err != nil {
return errors.New("get checkpoint failed") return errors.New("get checkpoint failed")
} }
@ -233,13 +228,13 @@ func TestCheckpointRegister(t *testing.T) {
// Register a stable checkpoint // Register a stable checkpoint
validateOperation(t, c, contractBackend, func() { validateOperation(t, c, contractBackend, func() {
c.SetCheckpoint(transactOpts, big.NewInt(int64(trustedCheckpoint.SectionIdx)), checkpointHash) c.SetCheckpoint(transactOpts, big.NewInt(0), checkpointHash0)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error { }, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(int64(trustedCheckpoint.SectionIdx))) hash, err := c.GetCheckpoint(nil, big.NewInt(0))
if err != nil { if err != nil {
return errors.New("get checkpoint failed") return errors.New("get checkpoint failed")
} }
if hash != checkpointHash { if hash != checkpointHash0 {
return errors.New("register stable checkpoint failed") return errors.New("register stable checkpoint failed")
} }
if !validateEvents(1, events) { if !validateEvents(1, events) {
@ -248,16 +243,16 @@ func TestCheckpointRegister(t *testing.T) {
return nil return nil
}, "register stable checkpoint") }, "register stable checkpoint")
fakeHash := crypto.Keccak256Hash([]byte("dead"), []byte("beef"), []byte("deadbeef")) newHash := crypto.Keccak256Hash([]byte("dead00"), []byte("beef00"), []byte("deadbeef00"))
// Modify the latest checkpoint // Modify the latest checkpoint
validateOperation(t, c, contractBackend, func() { validateOperation(t, c, contractBackend, func() {
c.SetCheckpoint(transactOpts, big.NewInt(int64(trustedCheckpoint.SectionIdx)), fakeHash) c.SetCheckpoint(transactOpts, big.NewInt(0), newHash)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error { }, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(int64(trustedCheckpoint.SectionIdx))) hash, err := c.GetCheckpoint(nil, big.NewInt(0))
if err != nil { if err != nil {
return errors.New("get checkpoint failed") return errors.New("get checkpoint failed")
} }
if hash != fakeHash { if hash != newHash {
return errors.New("register stable checkpoint failed") return errors.New("register stable checkpoint failed")
} }
if !validateEvents(1, events) { if !validateEvents(1, events) {
@ -265,4 +260,38 @@ func TestCheckpointRegister(t *testing.T) {
} }
return nil return nil
}, "modify latest checkpoint") }, "modify latest checkpoint")
contractBackend.ShiftBlocks(light.CheckpointFrequency)
// Register checkpoint 1
validateOperation(t, c, contractBackend, func() {
c.SetCheckpoint(transactOpts, big.NewInt(1), checkpointHash1)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(1))
if err != nil {
return errors.New("get checkpoint failed")
}
if hash != checkpointHash1 {
return errors.New("register stable checkpoint failed")
}
if !validateEvents(1, events) {
return errors.New("receive incorrect number of events")
}
return nil
}, "register stable checkpoint 1")
contractBackend.ShiftBlocks(light.CheckpointConfirmations)
newHash1 := crypto.Keccak256Hash([]byte("dead11"), []byte("beef11"), []byte("deadbeef11"))
// Modify the registered checkpoint after a very long time
validateOperation(t, c, contractBackend, func() {
c.SetCheckpoint(transactOpts, big.NewInt(1), newHash1)
}, func(events <-chan *contract.ContractNewCheckpointEvent, events2 <-chan *contract.ContractAddAdminEvent, events3 <-chan *contract.ContractRemoveAdminEvent) error {
hash, err := c.GetCheckpoint(nil, big.NewInt(1))
if err != nil {
return errors.New("get checkpoint failed")
}
if hash != checkpointHash1 {
return errors.New("checkpoint modified out of allowed time range")
}
return nil
}, "modify checkpoint out of allowed time range")
} }