You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
152 lines
3.8 KiB
152 lines
3.8 KiB
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"testing"
|
|
|
|
ics23 "github.com/confio/ics23/go"
|
|
"github.com/cosmos/iavl"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto/merkle"
|
|
"github.com/tendermint/tendermint/libs/bytes"
|
|
lcmock "github.com/tendermint/tendermint/light/rpc/mocks"
|
|
tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
|
|
rpcmock "github.com/tendermint/tendermint/rpc/client/mocks"
|
|
ctypes "github.com/tendermint/tendermint/rpc/core/types"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// TestABCIQuery tests ABCIQuery requests and verifies proofs. HAPPY PATH 😀
|
|
func TestABCIQuery(t *testing.T) {
|
|
tree, err := iavl.NewMutableTree(dbm.NewMemDB(), 100)
|
|
require.NoError(t, err)
|
|
|
|
var (
|
|
key = []byte("foo")
|
|
value = []byte("bar")
|
|
)
|
|
tree.Set(key, value)
|
|
|
|
commitmentProof, err := tree.GetMembershipProof(key)
|
|
require.NoError(t, err)
|
|
|
|
op := &testOp{
|
|
Spec: ics23.IavlSpec,
|
|
Key: key,
|
|
Proof: commitmentProof,
|
|
}
|
|
|
|
next := &rpcmock.Client{}
|
|
next.On(
|
|
"ABCIQueryWithOptions",
|
|
context.Background(),
|
|
mock.AnythingOfType("string"),
|
|
bytes.HexBytes(key),
|
|
mock.AnythingOfType("client.ABCIQueryOptions"),
|
|
).Return(&ctypes.ResultABCIQuery{
|
|
Response: abci.ResponseQuery{
|
|
Code: 0,
|
|
Key: key,
|
|
Value: value,
|
|
Height: 1,
|
|
ProofOps: &tmcrypto.ProofOps{
|
|
Ops: []tmcrypto.ProofOp{op.ProofOp()},
|
|
},
|
|
},
|
|
}, nil)
|
|
|
|
lc := &lcmock.LightClient{}
|
|
appHash, _ := hex.DecodeString("5EFD44055350B5CC34DBD26085347A9DBBE44EA192B9286A9FC107F40EA1FAC5")
|
|
lc.On("VerifyLightBlockAtHeight", context.Background(), int64(2), mock.AnythingOfType("time.Time")).Return(
|
|
&types.LightBlock{
|
|
SignedHeader: &types.SignedHeader{
|
|
Header: &types.Header{AppHash: appHash},
|
|
},
|
|
},
|
|
nil,
|
|
)
|
|
|
|
c := NewClient(next, lc,
|
|
KeyPathFn(func(_ string, key []byte) (merkle.KeyPath, error) {
|
|
kp := merkle.KeyPath{}
|
|
kp = kp.AppendKey(key, merkle.KeyEncodingURL)
|
|
return kp, nil
|
|
}))
|
|
c.RegisterOpDecoder("ics23:iavl", testOpDecoder)
|
|
res, err := c.ABCIQuery(context.Background(), "/store/accounts/key", key)
|
|
require.NoError(t, err)
|
|
|
|
assert.NotNil(t, res)
|
|
}
|
|
|
|
type testOp struct {
|
|
Spec *ics23.ProofSpec
|
|
Key []byte
|
|
Proof *ics23.CommitmentProof
|
|
}
|
|
|
|
var _ merkle.ProofOperator = testOp{}
|
|
|
|
func (op testOp) GetKey() []byte {
|
|
return op.Key
|
|
}
|
|
|
|
func (op testOp) ProofOp() tmcrypto.ProofOp {
|
|
bz, err := op.Proof.Marshal()
|
|
if err != nil {
|
|
panic(err.Error())
|
|
}
|
|
return tmcrypto.ProofOp{
|
|
Type: "ics23:iavl",
|
|
Key: op.Key,
|
|
Data: bz,
|
|
}
|
|
}
|
|
|
|
func (op testOp) Run(args [][]byte) ([][]byte, error) {
|
|
// calculate root from proof
|
|
root, err := op.Proof.Calculate()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not calculate root for proof: %v", err)
|
|
}
|
|
// Only support an existence proof or nonexistence proof (batch proofs currently unsupported)
|
|
switch len(args) {
|
|
case 0:
|
|
// Args are nil, so we verify the absence of the key.
|
|
absent := ics23.VerifyNonMembership(op.Spec, root, op.Proof, op.Key)
|
|
if !absent {
|
|
return nil, fmt.Errorf("proof did not verify absence of key: %s", string(op.Key))
|
|
}
|
|
case 1:
|
|
// Args is length 1, verify existence of key with value args[0]
|
|
if !ics23.VerifyMembership(op.Spec, root, op.Proof, op.Key, args[0]) {
|
|
return nil, fmt.Errorf("proof did not verify existence of key %s with given value %x", op.Key, args[0])
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("args must be length 0 or 1, got: %d", len(args))
|
|
}
|
|
|
|
return [][]byte{root}, nil
|
|
}
|
|
|
|
func testOpDecoder(pop tmcrypto.ProofOp) (merkle.ProofOperator, error) {
|
|
proof := &ics23.CommitmentProof{}
|
|
err := proof.Unmarshal(pop.Data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
op := testOp{
|
|
Key: pop.Key,
|
|
Spec: ics23.IavlSpec,
|
|
Proof: proof,
|
|
}
|
|
return op, nil
|
|
}
|