439 lines
13 KiB
Go
439 lines
13 KiB
Go
package vm
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"github.com/tendermint/iavl"
|
|
"github.com/tendermint/tendermint/crypto/merkle"
|
|
"github.com/tendermint/tendermint/crypto/secp256k1"
|
|
cmn "github.com/tendermint/tendermint/libs/common"
|
|
|
|
//nolint:staticcheck
|
|
v1 "github.com/ethereum/go-ethereum/core/vm/lightclient/v1"
|
|
v2 "github.com/ethereum/go-ethereum/core/vm/lightclient/v2"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
)
|
|
|
|
const (
|
|
uint64TypeLength uint64 = 8
|
|
precompileContractInputMetaDataLength uint64 = 32
|
|
consensusStateLengthBytesLength uint64 = 32
|
|
|
|
tmHeaderValidateResultMetaDataLength uint64 = 32
|
|
merkleProofValidateResultLength uint64 = 32
|
|
)
|
|
|
|
// input:
|
|
// consensus state length | consensus state | tendermint header |
|
|
// 32 bytes | | |
|
|
func decodeTendermintHeaderValidationInput(input []byte) (*v1.ConsensusState, *v1.Header, error) {
|
|
csLen := binary.BigEndian.Uint64(input[consensusStateLengthBytesLength-uint64TypeLength : consensusStateLengthBytesLength])
|
|
|
|
if consensusStateLengthBytesLength+csLen < consensusStateLengthBytesLength {
|
|
return nil, nil, fmt.Errorf("integer overflow, csLen: %d", csLen)
|
|
}
|
|
|
|
if uint64(len(input)) <= consensusStateLengthBytesLength+csLen {
|
|
return nil, nil, fmt.Errorf("expected payload size %d, actual size: %d", consensusStateLengthBytesLength+csLen, len(input))
|
|
}
|
|
|
|
cs, err := v1.DecodeConsensusState(input[consensusStateLengthBytesLength : consensusStateLengthBytesLength+csLen])
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
header, err := v1.DecodeHeader(input[consensusStateLengthBytesLength+csLen:])
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return &cs, header, nil
|
|
}
|
|
|
|
// tmHeaderValidate implemented as a native contract. Used to validate the light
|
|
// client's new header for tendermint v0.31.12 and its compatible version.
|
|
type tmHeaderValidate struct{}
|
|
|
|
func (c *tmHeaderValidate) RequiredGas(input []byte) uint64 {
|
|
return params.TendermintHeaderValidateGas
|
|
}
|
|
|
|
func (c *tmHeaderValidate) Run(input []byte) (result []byte, err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
err = fmt.Errorf("internal error: %v\n", r)
|
|
}
|
|
}()
|
|
|
|
if uint64(len(input)) <= precompileContractInputMetaDataLength {
|
|
return nil, fmt.Errorf("invalid input")
|
|
}
|
|
|
|
payloadLength := binary.BigEndian.Uint64(input[precompileContractInputMetaDataLength-uint64TypeLength : precompileContractInputMetaDataLength])
|
|
if uint64(len(input)) != payloadLength+precompileContractInputMetaDataLength {
|
|
return nil, fmt.Errorf("invalid input: input size should be %d, actual the size is %d", payloadLength+precompileContractInputMetaDataLength, len(input))
|
|
}
|
|
|
|
cs, header, err := decodeTendermintHeaderValidationInput(input[precompileContractInputMetaDataLength:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
validatorSetChanged, err := cs.ApplyHeader(header)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
consensusStateBytes, err := cs.EncodeConsensusState()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// result
|
|
// | validatorSetChanged | empty | consensusStateBytesLength | new consensusState |
|
|
// | 1 byte | 23 bytes | 8 bytes | |
|
|
lengthBytes := make([]byte, tmHeaderValidateResultMetaDataLength)
|
|
if validatorSetChanged {
|
|
copy(lengthBytes[:1], []byte{0x01})
|
|
}
|
|
consensusStateBytesLength := uint64(len(consensusStateBytes))
|
|
binary.BigEndian.PutUint64(lengthBytes[tmHeaderValidateResultMetaDataLength-uint64TypeLength:], consensusStateBytesLength)
|
|
|
|
result = append(lengthBytes, consensusStateBytes...)
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// iavlMerkleProofValidate implemented as a native contract.
|
|
type iavlMerkleProofValidate struct {
|
|
basicIavlMerkleProofValidate
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidate) RequiredGas(input []byte) uint64 {
|
|
return params.IAVLMerkleProofValidateGas
|
|
}
|
|
|
|
// input:
|
|
// | payload length | payload |
|
|
// | 32 bytes | |
|
|
func (c *iavlMerkleProofValidate) Run(input []byte) (result []byte, err error) {
|
|
return c.basicIavlMerkleProofValidate.Run(input)
|
|
}
|
|
|
|
// tmHeaderValidate implemented as a native contract.
|
|
type tmHeaderValidateNano struct{}
|
|
|
|
func (c *tmHeaderValidateNano) RequiredGas(input []byte) uint64 {
|
|
return params.TendermintHeaderValidateGas
|
|
}
|
|
|
|
func (c *tmHeaderValidateNano) Run(input []byte) (result []byte, err error) {
|
|
return nil, fmt.Errorf("suspend")
|
|
}
|
|
|
|
type iavlMerkleProofValidateNano struct{}
|
|
|
|
func (c *iavlMerkleProofValidateNano) RequiredGas(_ []byte) uint64 {
|
|
return params.IAVLMerkleProofValidateGas
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidateNano) Run(_ []byte) (result []byte, err error) {
|
|
return nil, fmt.Errorf("suspend")
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------------------------------------------------------
|
|
type iavlMerkleProofValidateMoran struct {
|
|
basicIavlMerkleProofValidate
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidateMoran) RequiredGas(_ []byte) uint64 {
|
|
return params.IAVLMerkleProofValidateGas
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidateMoran) Run(input []byte) (result []byte, err error) {
|
|
c.basicIavlMerkleProofValidate.verifiers = []merkle.ProofOpVerifier{
|
|
forbiddenAbsenceOpVerifier,
|
|
singleValueOpVerifier,
|
|
multiStoreOpVerifier,
|
|
forbiddenSimpleValueOpVerifier,
|
|
}
|
|
return c.basicIavlMerkleProofValidate.Run(input)
|
|
}
|
|
|
|
type iavlMerkleProofValidatePlanck struct {
|
|
basicIavlMerkleProofValidate
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidatePlanck) RequiredGas(_ []byte) uint64 {
|
|
return params.IAVLMerkleProofValidateGas
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidatePlanck) Run(input []byte) (result []byte, err error) {
|
|
c.basicIavlMerkleProofValidate.proofRuntime = v1.Ics23CompatibleProofRuntime()
|
|
c.basicIavlMerkleProofValidate.verifiers = []merkle.ProofOpVerifier{
|
|
forbiddenAbsenceOpVerifier,
|
|
singleValueOpVerifier,
|
|
multiStoreOpVerifier,
|
|
forbiddenSimpleValueOpVerifier,
|
|
}
|
|
c.basicIavlMerkleProofValidate.keyVerifier = keyVerifier
|
|
c.basicIavlMerkleProofValidate.opsVerifier = proofOpsVerifier
|
|
return c.basicIavlMerkleProofValidate.Run(input)
|
|
}
|
|
|
|
type iavlMerkleProofValidatePlato struct {
|
|
basicIavlMerkleProofValidate
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidatePlato) RequiredGas(_ []byte) uint64 {
|
|
return params.IAVLMerkleProofValidateGas
|
|
}
|
|
|
|
func (c *iavlMerkleProofValidatePlato) Run(input []byte) (result []byte, err error) {
|
|
c.basicIavlMerkleProofValidate.proofRuntime = v1.Ics23ProofRuntime()
|
|
c.basicIavlMerkleProofValidate.verifiers = []merkle.ProofOpVerifier{
|
|
forbiddenAbsenceOpVerifier,
|
|
singleValueOpVerifier,
|
|
multiStoreOpVerifier,
|
|
forbiddenSimpleValueOpVerifier,
|
|
}
|
|
c.basicIavlMerkleProofValidate.keyVerifier = keyVerifier
|
|
c.basicIavlMerkleProofValidate.opsVerifier = proofOpsVerifier
|
|
return c.basicIavlMerkleProofValidate.Run(input)
|
|
}
|
|
|
|
func successfulMerkleResult() []byte {
|
|
result := make([]byte, merkleProofValidateResultLength)
|
|
binary.BigEndian.PutUint64(result[merkleProofValidateResultLength-uint64TypeLength:], 0x01)
|
|
return result
|
|
}
|
|
|
|
type basicIavlMerkleProofValidate struct {
|
|
keyVerifier v1.KeyVerifier
|
|
opsVerifier merkle.ProofOpsVerifier
|
|
verifiers []merkle.ProofOpVerifier
|
|
proofRuntime *merkle.ProofRuntime
|
|
}
|
|
|
|
func (c *basicIavlMerkleProofValidate) Run(input []byte) (result []byte, err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
err = fmt.Errorf("internal error: %v\n", r)
|
|
}
|
|
}()
|
|
|
|
if uint64(len(input)) <= precompileContractInputMetaDataLength {
|
|
return nil, fmt.Errorf("invalid input: input should include %d bytes payload length and payload", precompileContractInputMetaDataLength)
|
|
}
|
|
|
|
payloadLength := binary.BigEndian.Uint64(input[precompileContractInputMetaDataLength-uint64TypeLength : precompileContractInputMetaDataLength])
|
|
if uint64(len(input)) != payloadLength+precompileContractInputMetaDataLength {
|
|
return nil, fmt.Errorf("invalid input: input size should be %d, actual the size is %d", payloadLength+precompileContractInputMetaDataLength, len(input))
|
|
}
|
|
|
|
kvmp, err := v1.DecodeKeyValueMerkleProof(input[precompileContractInputMetaDataLength:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if c.proofRuntime == nil {
|
|
kvmp.SetProofRuntime(v1.DefaultProofRuntime())
|
|
} else {
|
|
kvmp.SetProofRuntime(c.proofRuntime)
|
|
}
|
|
kvmp.SetVerifiers(c.verifiers)
|
|
kvmp.SetOpsVerifier(c.opsVerifier)
|
|
kvmp.SetKeyVerifier(c.keyVerifier)
|
|
|
|
valid := kvmp.Validate()
|
|
if !valid {
|
|
return nil, fmt.Errorf("invalid merkle proof")
|
|
}
|
|
|
|
return successfulMerkleResult(), nil
|
|
}
|
|
|
|
func forbiddenAbsenceOpVerifier(op merkle.ProofOperator) error {
|
|
if op == nil {
|
|
return nil
|
|
}
|
|
if _, ok := op.(iavl.IAVLAbsenceOp); ok {
|
|
return cmn.NewError("absence proof suspend")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func forbiddenSimpleValueOpVerifier(op merkle.ProofOperator) error {
|
|
if op == nil {
|
|
return nil
|
|
}
|
|
if _, ok := op.(merkle.SimpleValueOp); ok {
|
|
return cmn.NewError("simple value proof suspend")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func multiStoreOpVerifier(op merkle.ProofOperator) error {
|
|
if op == nil {
|
|
return nil
|
|
}
|
|
if mop, ok := op.(v1.MultiStoreProofOp); ok {
|
|
storeNames := make(map[string]bool, len(mop.Proof.StoreInfos))
|
|
for _, store := range mop.Proof.StoreInfos {
|
|
if exist := storeNames[store.Name]; exist {
|
|
return cmn.NewError("duplicated store")
|
|
} else {
|
|
storeNames[store.Name] = true
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func singleValueOpVerifier(op merkle.ProofOperator) error {
|
|
if op == nil {
|
|
return nil
|
|
}
|
|
if valueOp, ok := op.(iavl.IAVLValueOp); ok {
|
|
if len(valueOp.Proof.Leaves) != 1 {
|
|
return cmn.NewError("range proof suspended")
|
|
}
|
|
for _, innerNode := range valueOp.Proof.LeftPath {
|
|
if len(innerNode.Right) > 0 && len(innerNode.Left) > 0 {
|
|
return cmn.NewError("both right and left hash exit!")
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func proofOpsVerifier(poz merkle.ProofOperators) error {
|
|
if len(poz) != 2 {
|
|
return cmn.NewError("proof ops should be 2")
|
|
}
|
|
|
|
// for legacy proof type
|
|
if _, ok := poz[1].(v1.MultiStoreProofOp); ok {
|
|
if _, ok := poz[0].(iavl.IAVLValueOp); !ok {
|
|
return cmn.NewError("invalid proof op")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// for ics23 proof type
|
|
if op2, ok := poz[1].(v1.CommitmentOp); ok {
|
|
if op2.Type != v1.ProofOpSimpleMerkleCommitment {
|
|
return cmn.NewError("invalid proof op")
|
|
}
|
|
|
|
op1, ok := poz[0].(v1.CommitmentOp)
|
|
if !ok {
|
|
return cmn.NewError("invalid proof op")
|
|
}
|
|
|
|
if op1.Type != v1.ProofOpIAVLCommitment {
|
|
return cmn.NewError("invalid proof op")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
return cmn.NewError("invalid proof type")
|
|
}
|
|
|
|
func keyVerifier(key string) error {
|
|
// https://github.com/bnb-chain/tendermint/blob/72375a6f3d4a72831cc65e73363db89a0073db38/crypto/merkle/proof_key_path.go#L88
|
|
// since the upper function is ambiguous, `x:00` can be decoded to both kind of key type
|
|
// we check the key here to make sure the key will not start from `x:`
|
|
if strings.HasPrefix(url.PathEscape(key), "x:") {
|
|
return cmn.NewError("key should not start with x:")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// cometBFTLightBlockValidate implemented as a native contract. Used to validate the light blocks for CometBFT v0.37.0
|
|
// and its compatible version. Besides, in order to support the BLS cross-chain infrastructure, the SetRelayerAddress
|
|
// and SetBlsKey methods should be implemented for the validator.
|
|
type cometBFTLightBlockValidate struct{}
|
|
|
|
func (c *cometBFTLightBlockValidate) RequiredGas(input []byte) uint64 {
|
|
return params.CometBFTLightBlockValidateGas
|
|
}
|
|
|
|
func (c *cometBFTLightBlockValidate) run(input []byte, isHertz bool) (result []byte, err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
err = fmt.Errorf("internal error: %v\n", r)
|
|
}
|
|
}()
|
|
|
|
cs, block, err := v2.DecodeLightBlockValidationInput(input)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
validatorSetChanged, err := cs.ApplyLightBlock(block, isHertz)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
consensusStateBytes, err := cs.EncodeConsensusState()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result = v2.EncodeLightBlockValidationResult(validatorSetChanged, consensusStateBytes)
|
|
return result, nil
|
|
}
|
|
|
|
func (c *cometBFTLightBlockValidate) Run(input []byte) (result []byte, err error) {
|
|
return c.run(input, false)
|
|
}
|
|
|
|
type cometBFTLightBlockValidateHertz struct {
|
|
cometBFTLightBlockValidate
|
|
}
|
|
|
|
func (c *cometBFTLightBlockValidateHertz) Run(input []byte) (result []byte, err error) {
|
|
return c.run(input, true)
|
|
}
|
|
|
|
// secp256k1SignatureRecover implemented as a native contract.
|
|
type secp256k1SignatureRecover struct{}
|
|
|
|
func (c *secp256k1SignatureRecover) RequiredGas(input []byte) uint64 {
|
|
return params.EcrecoverGas
|
|
}
|
|
|
|
const (
|
|
tmPubKeyLength uint8 = 33
|
|
tmSignatureLength uint8 = 64
|
|
tmSignatureMsgHashLength uint8 = 32
|
|
)
|
|
|
|
// input:
|
|
// | tmPubKey | tmSignature | tmSignatureMsgHash |
|
|
// | 33 bytes | 64 bytes | 32 bytes |
|
|
func (c *secp256k1SignatureRecover) Run(input []byte) (result []byte, err error) {
|
|
if len(input) != int(tmPubKeyLength)+int(tmSignatureLength)+int(tmSignatureMsgHashLength) {
|
|
return nil, fmt.Errorf("invalid input")
|
|
}
|
|
|
|
return c.runTMSecp256k1Signature(
|
|
input[:tmPubKeyLength],
|
|
input[tmPubKeyLength:tmPubKeyLength+tmSignatureLength],
|
|
input[tmPubKeyLength+tmSignatureLength:],
|
|
)
|
|
}
|
|
|
|
func (c *secp256k1SignatureRecover) runTMSecp256k1Signature(pubkey, signatureStr, msgHash []byte) (result []byte, err error) {
|
|
tmPubKey := secp256k1.PubKeySecp256k1(pubkey)
|
|
ok := tmPubKey.VerifyBytesWithMsgHash(msgHash, signatureStr)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid signature")
|
|
}
|
|
return tmPubKey.Address().Bytes(), nil
|
|
}
|