certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Generalize auth/types.StdSignature (#4507) 

New Signature interface available in the top level types package.
auth.StdSignature implements such interface. User defined auth
module can now define their own custom signature types.

Work carried out in the context of the following issues:
- #4488
- #4487
This commit is contained in:
Alessio Treglia 2019-06-07 14:21:35 +01:00 committed by GitHub
parent c777fb9108
commit a32d5a46d7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 124 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.pending/breaking/sdk/4507-New-Signature-g Normal file
View File

@ -0,0 +1,3 @@
#4507 New `Signature` generic interface available in the top level types package.
`auth.StdSignature` implements such interface. User defined auth module can now
define their own custom signature types.

3
client/keys/import.go
View File

@ -3,8 +3,9 @@ package keys
import (
"io/ioutil"
"github.com/cosmos/cosmos-sdk/client/input"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client/input"
)
func importKeyCommand() *cobra.Command {

3
client/keys/list.go
View File

@ -1,8 +1,9 @@
package keys
import (
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client/flags"
)
func listKeysCmd() *cobra.Command {

3
client/keys/mnemonic_test.go
View File

@ -5,9 +5,10 @@ import (
"strings"
"testing"
"github.com/cosmos/cosmos-sdk/client/input"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/client/input"
)
func Test_RunMnemonicCmdNormal(t *testing.T) {

3
client/keys/update.go
View File

@ -3,8 +3,9 @@ package keys
import (
"fmt"
"github.com/cosmos/cosmos-sdk/client/input"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client/input"
)
func updateKeyCommand() *cobra.Command {

8
client/utils/utils_test.go
View File

@ -100,7 +100,7 @@ func TestReadStdTxFromFile(t *testing.T) {
// Build a test transaction
fee := authtypes.NewStdFee(50000, sdk.Coins{sdk.NewInt64Coin("atom", 150)})
stdTx := authtypes.NewStdTx([]sdk.Msg{}, fee, []authtypes.StdSignature{}, "foomemo")
stdTx := authtypes.NewStdTx([]sdk.Msg{}, fee, nil, "foomemo")
// Write it to the file
encodedTx, _ := cdc.MarshalJSON(stdTx)
@ -143,8 +143,8 @@ func TestValidateCmd(t *testing.T) {
}{
{"misspelled command", []string{"comission"}, true},
{"no command provided", []string{}, false},
{"help flag", []string{"comission", "--help"}, false},
{"shorthand help flag", []string{"comission", "-h"}, false},
{"help flag", []string{"commission", "--help"}, false},
{"shorthand help flag", []string{"commission", "-h"}, false},
}
for _, tt := range tests {
@ -158,7 +158,7 @@ func TestValidateCmd(t *testing.T) {
func compareEncoders(t *testing.T, expected sdk.TxEncoder, actual sdk.TxEncoder) {
msgs := []sdk.Msg{sdk.NewTestMsg(addr)}
tx := authtypes.NewStdTx(msgs, authtypes.StdFee{}, []authtypes.StdSignature{}, "")
tx := authtypes.NewStdTx(msgs, authtypes.StdFee{}, []sdk.Signature{}, "")
defaultEncoderBytes, err := expected(tx)
require.NoError(t, err)

6
docs/spec/auth/03_types.md
View File

@ -20,9 +20,9 @@ type StdFee struct {
## StdSignature
A `StdSignature` is the combination of an optional public key and a cryptographic signature
as a byte array. The SDK is agnostic to particular key or signature formats and supports any
supported by the `PubKey` interface.
`StdSignature` implements the `sdk.Signature` interface and consists of a combination of an
optional public key and a cryptographic signature as a byte slice. The SDK is agnostic to
particular key or signature formats and supports any supported by the `PubKey` interface.
```golang
type StdSignature struct {

3
simapp/test_util.go
View File

@ -5,10 +5,11 @@ import (
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tendermint/libs/db"
bam "github.com/cosmos/cosmos-sdk/baseapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
dbm "github.com/tendermint/tendermint/libs/db"
)
// NewSimAppUNSAFE is used for debugging purposes only.

1
types/codec.go
View File

@ -6,4 +6,5 @@ import "github.com/cosmos/cosmos-sdk/codec"
func RegisterCodec(cdc *codec.Codec) {
cdc.RegisterInterface((*Msg)(nil), nil)
cdc.RegisterInterface((*Tx)(nil), nil)
cdc.RegisterInterface((*Signature)(nil), nil)
}

3
types/coin_test.go
View File

@ -4,9 +4,10 @@ import (
"strings"
"testing"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/codec"
)
var (

8
types/tx_msg.go
View File

@ -2,6 +2,8 @@ package types
import (
"encoding/json"
"github.com/tendermint/tendermint/crypto"
)
// Transactions messages must fulfill the Msg
@ -42,6 +44,12 @@ type Tx interface {
//__________________________________________________________
// Signature defines the properties of the signature payload.
type Signature interface {
GetPubKey() crypto.PubKey
GetSignature() []byte
}
// TxDecoder unmarshals transaction bytes
type TxDecoder func(txBytes []byte) (Tx, Error)

1
x/auth/alias.go
View File

@ -46,6 +46,7 @@ var (
NewStdTx = types.NewStdTx
CountSubKeys = types.CountSubKeys
NewStdFee = types.NewStdFee
NewStdSignature = types.NewStdSignature
StdSignBytes = types.StdSignBytes
DefaultTxDecoder = types.DefaultTxDecoder
DefaultTxEncoder = types.DefaultTxEncoder

21
x/auth/ante.go
View File

@ -136,7 +136,8 @@ func NewAnteHandler(ak AccountKeeper, fck FeeCollectionKeeper, sigGasConsumer Si
// check signature, return account with incremented nonce
signBytes := GetSignBytes(newCtx.ChainID(), stdTx, signerAccs[i], isGenesis)
signerAccs[i], res = processSig(newCtx, signerAccs[i], stdSigs[i], signBytes, simulate, params, sigGasConsumer)
signerAccs[i], res = processSig(newCtx, signerAccs[i], stdSigs[i], signBytes,
simulate, params, sigGasConsumer)
if !res.IsOK() {
return newCtx, res, true
}
@ -165,7 +166,7 @@ func ValidateSigCount(stdTx StdTx, params Params) sdk.Result {
sigCount := 0
for i := 0; i < len(stdSigs); i++ {
sigCount += CountSubKeys(stdSigs[i].PubKey)
sigCount += CountSubKeys(stdSigs[i].GetPubKey())
if uint64(sigCount) > params.TxSigLimit {
return sdk.ErrTooManySignatures(
fmt.Sprintf("signatures: %d, limit: %d", sigCount, params.TxSigLimit),
@ -194,7 +195,7 @@ func ValidateMemo(stdTx StdTx, params Params) sdk.Result {
// verify the signature and increment the sequence. If the account doesn't have
// a pubkey, set it.
func processSig(
ctx sdk.Context, acc Account, sig StdSignature, signBytes []byte, simulate bool, params Params,
ctx sdk.Context, acc Account, sig sdk.Signature, signBytes []byte, simulate bool, params Params,
sigGasConsumer SignatureVerificationGasConsumer,
) (updatedAcc Account, res sdk.Result) {
@ -216,11 +217,11 @@ func processSig(
consumeSimSigGas(ctx.GasMeter(), pubKey, sig, params)
}
if res := sigGasConsumer(ctx.GasMeter(), sig.Signature, pubKey, params); !res.IsOK() {
if res := sigGasConsumer(ctx.GasMeter(), sig.GetSignature(), pubKey, params); !res.IsOK() {
return nil, res
}
if !simulate && !pubKey.VerifyBytes(signBytes, sig.Signature) {
if !simulate && !pubKey.VerifyBytes(signBytes, sig.GetSignature()) {
return nil, sdk.ErrUnauthorized("signature verification failed; verify correct account sequence and chain-id").Result()
}
@ -231,9 +232,9 @@ func processSig(
return acc, res
}
func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig StdSignature, params Params) {
simSig := StdSignature{PubKey: pubkey}
if len(sig.Signature) == 0 {
func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig sdk.Signature, params Params) {
simSig := NewStdSignature(pubkey, nil)
if len(sig.GetSignature()) == 0 {
simSig.Signature = simSecp256k1Sig[:]
}
@ -252,7 +253,7 @@ func consumeSimSigGas(gasmeter sdk.GasMeter, pubkey crypto.PubKey, sig StdSignat
// ProcessPubKey verifies that the given account address matches that of the
// StdSignature. In addition, it will set the public key of the account if it
// has not been set.
func ProcessPubKey(acc Account, sig StdSignature, simulate bool) (crypto.PubKey, sdk.Result) {
func ProcessPubKey(acc Account, sig sdk.Signature, simulate bool) (crypto.PubKey, sdk.Result) {
// If pubkey is not known for account, set it from the StdSignature.
pubKey := acc.GetPubKey()
if simulate {
@ -268,7 +269,7 @@ func ProcessPubKey(acc Account, sig StdSignature, simulate bool) (crypto.PubKey,
}
if pubKey == nil {
pubKey = sig.PubKey
pubKey = sig.GetPubKey()
if pubKey == nil {
return nil, sdk.ErrInvalidPubKey("PubKey not found").Result()
}

13
x/auth/ante_test.go
View File

@ -515,7 +515,8 @@ func TestAnteHandlerSetPubKey(t *testing.T) {
msgs = []sdk.Msg{msg}
tx = NewTestTx(ctx, msgs, privs, []uint64{1}, seqs, fee)
sigs := tx.(types.StdTx).GetSignatures()
sigs[0].PubKey = nil
sig := sigs[0].(StdSignature)
sig.PubKey = nil
checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeInvalidPubKey)
acc2 = input.ak.GetAccount(ctx, addr2)
@ -551,11 +552,11 @@ func TestProcessPubKey(t *testing.T) {
args args
wantErr bool
}{
{"no sigs, simulate off", args{acc1, StdSignature{}, false}, true},
{"no sigs, simulate on", args{acc1, StdSignature{}, true}, false},
{"no sigs, account with pub, simulate on", args{acc2, StdSignature{}, true}, false},
{"pubkey doesn't match addr, simulate off", args{acc1, StdSignature{PubKey: priv2.PubKey()}, false}, true},
{"pubkey doesn't match addr, simulate on", args{acc1, StdSignature{PubKey: priv2.PubKey()}, true}, false},
{"no sigs, simulate off", args{acc1, NewStdSignature(nil, nil), false}, true},
{"no sigs, simulate on", args{acc1, NewStdSignature(nil, nil), true}, false},
{"no sigs, account with pub, simulate on", args{acc2, NewStdSignature(nil, nil), true}, false},
{"pubkey doesn't match addr, simulate off", args{acc1, NewStdSignature(priv2.PubKey(), nil), false}, true},
{"pubkey doesn't match addr, simulate on", args{acc1, NewStdSignature(priv2.PubKey(), nil), true}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {

4
x/auth/client/cli/tx_multisign.go
View File

@ -18,6 +18,7 @@ import (
"github.com/cosmos/cosmos-sdk/client/utils"
"github.com/cosmos/cosmos-sdk/codec"
crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/auth/types"
)
@ -119,7 +120,8 @@ func makeMultiSignCmd(cdc *codec.Codec) func(cmd *cobra.Command, args []string)
}
newStdSig := types.StdSignature{Signature: cdc.MustMarshalBinaryBare(multisigSig), PubKey: multisigPub}
newTx := types.NewStdTx(stdTx.GetMsgs(), stdTx.Fee, []types.StdSignature{newStdSig}, stdTx.GetMemo())
newTx := types.NewStdTx(stdTx.GetMsgs(), stdTx.Fee, []sdk.Signature{newStdSig},
stdTx.GetMemo())
sigOnly := viper.GetBool(flagSigOnly)
var json []byte

8
x/auth/client/cli/tx_sign.go
View File

@ -206,7 +206,7 @@ func printAndValidateSigs(
}
for i, sig := range sigs {
sigAddr := sdk.AccAddress(sig.Address())
sigAddr := sdk.AccAddress(sig.GetPubKey().Address())
sigSanity := "OK"
var (
@ -233,16 +233,16 @@ func printAndValidateSigs(
stdTx.Fee, stdTx.GetMsgs(), stdTx.GetMemo(),
)
if ok := sig.VerifyBytes(sigBytes, sig.Signature); !ok {
if ok := sig.GetPubKey().VerifyBytes(sigBytes, sig.GetSignature()); !ok {
sigSanity = "ERROR: signature invalid"
success = false
}
}
multiPK, ok := sig.PubKey.(multisig.PubKeyMultisigThreshold)
multiPK, ok := sig.GetPubKey().(multisig.PubKeyMultisigThreshold)
if ok {
var multiSig multisig.Multisignature
cliCtx.Codec.MustUnmarshalBinaryBare(sig.Signature, &multiSig)
cliCtx.Codec.MustUnmarshalBinaryBare(sig.GetSignature(), &multiSig)
var b strings.Builder
b.WriteString("\n MultiSig Signatures:\n")

5
x/auth/genaccounts/genesis_state_test.go
View File

@ -3,10 +3,11 @@ package genaccounts
import (
"testing"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
)
func TestSanitize(t *testing.T) {

1
x/auth/types/codec.go
View File

@ -13,6 +13,7 @@ func RegisterCodec(cdc *codec.Codec) {
cdc.RegisterConcrete(&ContinuousVestingAccount{}, "auth/ContinuousVestingAccount", nil)
cdc.RegisterConcrete(&DelayedVestingAccount{}, "auth/DelayedVestingAccount", nil)
cdc.RegisterConcrete(StdTx{}, "auth/StdTx", nil)
cdc.RegisterConcrete(StdSignature{}, "auth/StdSignature", nil)
}
// RegisterBaseAccount most users shouldn't use this, but this comes in handy for tests.

18
x/auth/types/stdtx.go
View File

@ -13,6 +13,7 @@ import (
var (
_ sdk.Tx = (*StdTx)(nil)
_ sdk.Signature = (*StdSignature)(nil)
maxGasWanted = uint64((1 << 63) - 1)
)
@ -22,11 +23,11 @@ var (
type StdTx struct {
Msgs []sdk.Msg `json:"msg"`
Fee StdFee `json:"fee"`
Signatures []StdSignature `json:"signatures"`
Signatures []sdk.Signature `json:"signatures"`
Memo string `json:"memo"`
}
func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []StdSignature, memo string) StdTx {
func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []sdk.Signature, memo string) StdTx {
return StdTx{
Msgs: msgs,
Fee: fee,
@ -104,7 +105,7 @@ func (tx StdTx) GetMemo() string { return tx.Memo }
// CONTRACT: If the signature is missing (ie the Msg is
// invalid), then the corresponding signature is
// .Empty().
func (tx StdTx) GetSignatures() []StdSignature { return tx.Signatures }
func (tx StdTx) GetSignatures() []sdk.Signature { return tx.Signatures }
//__________________________________________________________
@ -191,6 +192,17 @@ type StdSignature struct {
Signature []byte `json:"signature"`
}
// NewStdSignature constructs a new StdSignature instance.
func NewStdSignature(pubKey crypto.PubKey, signature []byte) StdSignature {
return StdSignature{PubKey: pubKey, Signature: signature}
}
// GetPubKey returns the embedded crypto.PubKey type.
func (sig StdSignature) GetPubKey() crypto.PubKey { return sig.PubKey }
// GetSignature returns the embedded byte signature.
func (sig StdSignature) GetSignature() []byte { return sig.Signature }
// DefaultTxDecoder logic for standard transaction decoding
func DefaultTxDecoder(cdc *codec.Codec) sdk.TxDecoder {
return func(txBytes []byte) (sdk.Tx, sdk.Error) {

14
x/auth/types/stdtx_test.go
View File

@ -1,10 +1,12 @@
package types
import (
"bytes"
"fmt"
"testing"
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
@ -22,7 +24,7 @@ var (
func TestStdTx(t *testing.T) {
msgs := []sdk.Msg{sdk.NewTestMsg(addr)}
fee := NewTestStdFee()
sigs := []StdSignature{}
sigs := []sdk.Signature{}
tx := NewStdTx(msgs, fee, sigs, "")
require.Equal(t, msgs, tx.GetMsgs())
@ -121,7 +123,7 @@ func TestDefaultTxEncoder(t *testing.T) {
msgs := []sdk.Msg{sdk.NewTestMsg(addr)}
fee := NewTestStdFee()
sigs := []StdSignature{}
sigs := []sdk.Signature{}
tx := NewStdTx(msgs, fee, sigs, "")
@ -133,3 +135,11 @@ func TestDefaultTxEncoder(t *testing.T) {
require.NoError(t, err)
require.Equal(t, cdcBytes, encoderBytes)
}
func TestNewStdSignature(t *testing.T) {
pub := ed25519.GenPrivKey().PubKey()
sigBytes := []byte("data")
got := NewStdSignature(pub, sigBytes)
require.True(t, bytes.Equal(got.GetSignature(), sigBytes))
require.True(t, got.GetPubKey().Equals(pub))
}

12
x/auth/types/test_common.go
View File

@ -70,7 +70,7 @@ func KeyTestPubAddr() (crypto.PrivKey, crypto.PubKey, sdk.AccAddress) {
}
func NewTestTx(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey, accNums []uint64, seqs []uint64, fee StdFee) sdk.Tx {
sigs := make([]StdSignature, len(privs))
sigs := make([]sdk.Signature, len(privs))
for i, priv := range privs {
signBytes := StdSignBytes(ctx.ChainID(), accNums[i], seqs[i], fee, msgs, "")
@ -79,7 +79,7 @@ func NewTestTx(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey, accNums
panic(err)
}
sigs[i] = StdSignature{PubKey: priv.PubKey(), Signature: sig}
sigs[i] = NewStdSignature(priv.PubKey(), sig)
}
tx := NewStdTx(msgs, fee, sigs, "")
@ -87,7 +87,7 @@ func NewTestTx(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey, accNums
}
func NewTestTxWithMemo(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey, accNums []uint64, seqs []uint64, fee StdFee, memo string) sdk.Tx {
sigs := make([]StdSignature, len(privs))
sigs := make([]sdk.Signature, len(privs))
for i, priv := range privs {
signBytes := StdSignBytes(ctx.ChainID(), accNums[i], seqs[i], fee, msgs, memo)
@ -96,7 +96,7 @@ func NewTestTxWithMemo(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey,
panic(err)
}
sigs[i] = StdSignature{PubKey: priv.PubKey(), Signature: sig}
sigs[i] = NewStdSignature(priv.PubKey(), sig)
}
tx := NewStdTx(msgs, fee, sigs, memo)
@ -104,14 +104,14 @@ func NewTestTxWithMemo(ctx sdk.Context, msgs []sdk.Msg, privs []crypto.PrivKey,
}
func NewTestTxWithSignBytes(msgs []sdk.Msg, privs []crypto.PrivKey, accNums []uint64, seqs []uint64, fee StdFee, signBytes []byte, memo string) sdk.Tx {
sigs := make([]StdSignature, len(privs))
sigs := make([]sdk.Signature, len(privs))
for i, priv := range privs {
sig, err := priv.Sign(signBytes)
if err != nil {
panic(err)
}
sigs[i] = StdSignature{PubKey: priv.PubKey(), Signature: sig}
sigs[i] = NewStdSignature(priv.PubKey(), sig)
}
tx := NewStdTx(msgs, fee, sigs, memo)

16
x/auth/types/txbuilder.go
View File

@ -214,7 +214,7 @@ func (bldr TxBuilder) Sign(name, passphrase string, msg StdSignMsg) ([]byte, err
return nil, err
}
return bldr.txEncoder(NewStdTx(msg.Msgs, msg.Fee, []StdSignature{sig}, msg.Memo))
return bldr.txEncoder(NewStdTx(msg.Msgs, msg.Fee, []sdk.Signature{sig}, msg.Memo))
}
// BuildAndSign builds a single message to be signed, and signs a transaction
@ -237,7 +237,7 @@ func (bldr TxBuilder) BuildTxForSim(msgs []sdk.Msg) ([]byte, error) {
}
// the ante handler will populate with a sentinel pubkey
sigs := []StdSignature{{}}
sigs := []sdk.Signature{NewStdSignature(nil, nil)}
return bldr.txEncoder(NewStdTx(signMsg.Msgs, signMsg.Fee, sigs, signMsg.Memo))
}
@ -262,7 +262,7 @@ func (bldr TxBuilder) SignStdTx(name, passphrase string, stdTx StdTx, appendSig
sigs := stdTx.GetSignatures()
if len(sigs) == 0 || !appendSig {
sigs = []StdSignature{stdSignature}
sigs = []sdk.Signature{stdSignature}
} else {
sigs = append(sigs, stdSignature)
}
@ -271,8 +271,8 @@ func (bldr TxBuilder) SignStdTx(name, passphrase string, stdTx StdTx, appendSig
}
// MakeSignature builds a StdSignature given keybase, key name, passphrase, and a StdSignMsg.
func MakeSignature(keybase crkeys.Keybase, name, passphrase string,
msg StdSignMsg) (sig StdSignature, err error) {
func MakeSignature(keybase crkeys.Keybase, name,
passphrase string, msg StdSignMsg) (sig sdk.Signature, err error) {
if keybase == nil {
keybase, err = keys.NewKeyBaseFromHomeFlag()
if err != nil {
@ -284,8 +284,6 @@ func MakeSignature(keybase crkeys.Keybase, name, passphrase string,
if err != nil {
return
}
return StdSignature{
PubKey: pubkey,
Signature: sigBytes,
}, nil
return NewStdSignature(pubkey, sigBytes), nil
}

3
x/distribution/proposal_handler_test.go
View File

@ -5,9 +5,10 @@ import (
"github.com/tendermint/tendermint/crypto/ed25519"
"github.com/stretchr/testify/require"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
"github.com/stretchr/testify/require"
)
var (

5
x/genutil/genesis_state_test.go
View File

@ -3,11 +3,12 @@ package genutil
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
)
var (

3
x/gov/types/keys_test.go
View File

@ -4,9 +4,10 @@ import (
"testing"
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
)
var addr = sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address())

7
x/mock/app.go
View File

@ -217,7 +217,7 @@ func GenTx(msgs []sdk.Msg, accnums []uint64, seq []uint64, priv ...crypto.PrivKe
Gas: 100000,
}
sigs := make([]auth.StdSignature, len(priv))
sigs := make([]sdk.Signature, len(priv))
memo := "testmemotestmemo"
for i, p := range priv {
@ -226,10 +226,7 @@ func GenTx(msgs []sdk.Msg, accnums []uint64, seq []uint64, priv ...crypto.PrivKe
panic(err)
}
sigs[i] = auth.StdSignature{
PubKey: p.PubKey(),
Signature: sig,
}
sigs[i] = auth.NewStdSignature(p.PubKey(), sig)
}
return auth.NewStdTx(msgs, fee, sigs, memo)

2
x/mock/app_test.go
View File

@ -30,7 +30,7 @@ func (tx testMsg) GetMsg() sdk.Msg { return tx }
func (tx testMsg) GetMemo() string { return "" }
func (tx testMsg) GetSignBytes() []byte { return nil }
func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers }
func (tx testMsg) GetSignatures() []auth.StdSignature { return nil }
func (tx testMsg) GetSignatures() []sdk.Signature { return nil }
func (tx testMsg) ValidateBasic() sdk.Error {
if tx.positiveNum >= 0 {
return nil

3
x/staking/exported/exported.go
View File

@ -1,8 +1,9 @@
package exported
import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/tendermint/tendermint/crypto"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// DelegationI delegation bond for a delegated proof of stake system