-
Notifications
You must be signed in to change notification settings - Fork 1.7k
/
seed.go
86 lines (73 loc) · 2.78 KB
/
seed.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package proof
import (
"math/big"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require"
"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
)
// Seed represents a VRF seed as a serialized uint256
type Seed [32]byte
// BigToSeed returns seed x represented as a Seed, or an error if x is too big
func BigToSeed(x *big.Int) (Seed, error) {
seed, err := utils.Uint256ToBytes(x)
if err != nil {
return Seed{}, err
}
return Seed(common.BytesToHash(seed)), nil
}
// Big returns the uint256 seed represented by s
func (s *Seed) Big() *big.Int {
return common.Hash(*s).Big()
}
// PreSeedData contains the data the VRF provider needs to compute the final VRF
// output and marshal the proof for transmission to the VRFCoordinator contract.
type PreSeedData struct {
PreSeed Seed // Seed to be mixed with hash of containing block
BlockHash common.Hash // Hash of block containing VRF request
BlockNum uint64 // Cardinal number of block containing VRF request
}
type PreSeedDataV2 struct {
PreSeed Seed // Seed to be mixed with hash of containing block
BlockHash common.Hash // Hash of block containing VRF request
BlockNum uint64 // Cardinal number of block containing VRF request
SubId uint64
CallbackGasLimit uint32
NumWords uint32
Sender common.Address
}
type PreSeedDataV2Plus struct {
PreSeed Seed // Seed to be mixed with hash of containing block
BlockHash common.Hash // Hash of block containing VRF request
BlockNum uint64 // Cardinal number of block containing VRF request
SubId *big.Int
CallbackGasLimit uint32
NumWords uint32
Sender common.Address
ExtraArgs []byte
}
// FinalSeed is the seed which is actually passed to the VRF proof generator,
// given the pre-seed and the hash of the block in which the VRFCoordinator
// emitted the log for the request this is responding to.
func FinalSeed(s PreSeedData) (finalSeed *big.Int) {
seedHashMsg := append(s.PreSeed[:], s.BlockHash.Bytes()...)
return utils.MustHash(string(seedHashMsg)).Big()
}
func FinalSeedV2(s PreSeedDataV2) (finalSeed *big.Int) {
seedHashMsg := append(s.PreSeed[:], s.BlockHash.Bytes()...)
return utils.MustHash(string(seedHashMsg)).Big()
}
func FinalSeedV2Plus(s PreSeedDataV2Plus) (finalSeed *big.Int) {
seedHashMsg := append(s.PreSeed[:], s.BlockHash.Bytes()...)
return utils.MustHash(string(seedHashMsg)).Big()
}
func TestXXXSeedData(t *testing.T, preSeed *big.Int, blockHash common.Hash,
blockNum int) PreSeedData {
seedAsSeed, err := BigToSeed(big.NewInt(0x10))
require.NoError(t, err, "seed %x out of range", 0x10)
return PreSeedData{
PreSeed: seedAsSeed,
BlockNum: uint64(blockNum),
BlockHash: blockHash,
}
}