301 lines
8.1 KiB
Go
301 lines
8.1 KiB
Go
package types
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
"github.com/tendermint/tendermint/crypto"
|
|
"github.com/tendermint/tendermint/crypto/multisig"
|
|
yaml "gopkg.in/yaml.v2"
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
"github.com/cosmos/cosmos-sdk/x/auth/exported"
|
|
)
|
|
|
|
var (
|
|
_ sdk.Tx = (*StdTx)(nil)
|
|
|
|
maxGasWanted = uint64((1 << 63) - 1)
|
|
)
|
|
|
|
// StdTx is a standard way to wrap a Msg with Fee and Signatures.
|
|
// NOTE: the first signature is the fee payer (Signatures must not be nil).
|
|
type StdTx struct {
|
|
Msgs []sdk.Msg `json:"msg" yaml:"msg"`
|
|
Fee StdFee `json:"fee" yaml:"fee"`
|
|
Signatures []StdSignature `json:"signatures" yaml:"signatures"`
|
|
Memo string `json:"memo" yaml:"memo"`
|
|
}
|
|
|
|
func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []StdSignature, memo string) StdTx {
|
|
return StdTx{
|
|
Msgs: msgs,
|
|
Fee: fee,
|
|
Signatures: sigs,
|
|
Memo: memo,
|
|
}
|
|
}
|
|
|
|
// GetMsgs returns the all the transaction's messages.
|
|
func (tx StdTx) GetMsgs() []sdk.Msg { return tx.Msgs }
|
|
|
|
// ValidateBasic does a simple and lightweight validation check that doesn't
|
|
// require access to any other information.
|
|
func (tx StdTx) ValidateBasic() error {
|
|
stdSigs := tx.GetSignatures()
|
|
|
|
if tx.Fee.Gas > maxGasWanted {
|
|
return sdkerrors.Wrapf(
|
|
sdkerrors.ErrInvalidRequest,
|
|
"invalid gas supplied; %d > %d", tx.Fee.Gas, maxGasWanted,
|
|
)
|
|
}
|
|
if tx.Fee.Amount.IsAnyNegative() {
|
|
return sdkerrors.Wrapf(
|
|
sdkerrors.ErrInsufficientFee,
|
|
"invalid fee provided: %s", tx.Fee.Amount,
|
|
)
|
|
}
|
|
if len(stdSigs) == 0 {
|
|
return sdkerrors.ErrNoSignatures
|
|
}
|
|
if len(stdSigs) != len(tx.GetSigners()) {
|
|
return sdkerrors.Wrapf(
|
|
sdkerrors.ErrUnauthorized,
|
|
"wrong number of signers; expected %d, got %d", tx.GetSigners(), len(stdSigs),
|
|
)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CountSubKeys counts the total number of keys for a multi-sig public key.
|
|
func CountSubKeys(pub crypto.PubKey) int {
|
|
v, ok := pub.(multisig.PubKeyMultisigThreshold)
|
|
if !ok {
|
|
return 1
|
|
}
|
|
|
|
numKeys := 0
|
|
for _, subkey := range v.PubKeys {
|
|
numKeys += CountSubKeys(subkey)
|
|
}
|
|
|
|
return numKeys
|
|
}
|
|
|
|
// GetSigners returns the addresses that must sign the transaction.
|
|
// Addresses are returned in a deterministic order.
|
|
// They are accumulated from the GetSigners method for each Msg
|
|
// in the order they appear in tx.GetMsgs().
|
|
// Duplicate addresses will be omitted.
|
|
func (tx StdTx) GetSigners() []sdk.AccAddress {
|
|
seen := map[string]bool{}
|
|
var signers []sdk.AccAddress
|
|
for _, msg := range tx.GetMsgs() {
|
|
for _, addr := range msg.GetSigners() {
|
|
if !seen[addr.String()] {
|
|
signers = append(signers, addr)
|
|
seen[addr.String()] = true
|
|
}
|
|
}
|
|
}
|
|
return signers
|
|
}
|
|
|
|
// GetMemo returns the memo
|
|
func (tx StdTx) GetMemo() string { return tx.Memo }
|
|
|
|
// GetSignatures returns the signature of signers who signed the Msg.
|
|
// CONTRACT: Length returned is same as length of
|
|
// pubkeys returned from MsgKeySigners, and the order
|
|
// matches.
|
|
// CONTRACT: If the signature is missing (ie the Msg is
|
|
// invalid), then the corresponding signature is
|
|
// .Empty().
|
|
func (tx StdTx) GetSignatures() [][]byte {
|
|
sigs := make([][]byte, len(tx.Signatures))
|
|
for i, stdSig := range tx.Signatures {
|
|
sigs[i] = stdSig.Signature
|
|
}
|
|
return sigs
|
|
}
|
|
|
|
// GetPubkeys returns the pubkeys of signers if the pubkey is included in the signature
|
|
// If pubkey is not included in the signature, then nil is in the slice instead
|
|
func (tx StdTx) GetPubKeys() []crypto.PubKey {
|
|
pks := make([]crypto.PubKey, len(tx.Signatures))
|
|
for i, stdSig := range tx.Signatures {
|
|
pks[i] = stdSig.PubKey
|
|
}
|
|
return pks
|
|
}
|
|
|
|
// GetSignBytes returns the signBytes of the tx for a given signer
|
|
func (tx StdTx) GetSignBytes(ctx sdk.Context, acc exported.Account) []byte {
|
|
genesis := ctx.BlockHeight() == 0
|
|
chainID := ctx.ChainID()
|
|
var accNum uint64
|
|
if !genesis {
|
|
accNum = acc.GetAccountNumber()
|
|
}
|
|
|
|
return StdSignBytes(
|
|
chainID, accNum, acc.GetSequence(), tx.Fee, tx.Msgs, tx.Memo,
|
|
)
|
|
}
|
|
|
|
// GetGas returns the Gas in StdFee
|
|
func (tx StdTx) GetGas() uint64 { return tx.Fee.Gas }
|
|
|
|
// GetFee returns the FeeAmount in StdFee
|
|
func (tx StdTx) GetFee() sdk.Coins { return tx.Fee.Amount }
|
|
|
|
// FeePayer returns the address that is responsible for paying fee
|
|
// StdTx returns the first signer as the fee payer
|
|
// If no signers for tx, return empty address
|
|
func (tx StdTx) FeePayer() sdk.AccAddress {
|
|
if tx.GetSigners() != nil {
|
|
return tx.GetSigners()[0]
|
|
}
|
|
return sdk.AccAddress{}
|
|
}
|
|
|
|
// NewStdFee returns a new instance of StdFee
|
|
func NewStdFee(gas uint64, amount sdk.Coins) StdFee {
|
|
return StdFee{
|
|
Amount: amount,
|
|
Gas: gas,
|
|
}
|
|
}
|
|
|
|
// Bytes for signing later
|
|
func (fee StdFee) Bytes() []byte {
|
|
// normalize. XXX
|
|
// this is a sign of something ugly
|
|
// (in the lcd_test, client side its null,
|
|
// server side its [])
|
|
if len(fee.Amount) == 0 {
|
|
fee.Amount = sdk.NewCoins()
|
|
}
|
|
|
|
bz, err := codec.Cdc.MarshalJSON(fee) // TODO
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return bz
|
|
}
|
|
|
|
// GasPrices returns the gas prices for a StdFee.
|
|
//
|
|
// NOTE: The gas prices returned are not the true gas prices that were
|
|
// originally part of the submitted transaction because the fee is computed
|
|
// as fee = ceil(gasWanted * gasPrices).
|
|
func (fee StdFee) GasPrices() sdk.DecCoins {
|
|
return sdk.NewDecCoinsFromCoins(fee.Amount...).QuoDec(sdk.NewDec(int64(fee.Gas)))
|
|
}
|
|
|
|
//__________________________________________________________
|
|
|
|
// StdSignDoc is replay-prevention structure.
|
|
// It includes the result of msg.GetSignBytes(),
|
|
// as well as the ChainID (prevent cross chain replay)
|
|
// and the Sequence numbers for each signature (prevent
|
|
// inchain replay and enforce tx ordering per account).
|
|
type StdSignDoc struct {
|
|
AccountNumber uint64 `json:"account_number" yaml:"account_number"`
|
|
ChainID string `json:"chain_id" yaml:"chain_id"`
|
|
Fee json.RawMessage `json:"fee" yaml:"fee"`
|
|
Memo string `json:"memo" yaml:"memo"`
|
|
Msgs []json.RawMessage `json:"msgs" yaml:"msgs"`
|
|
Sequence uint64 `json:"sequence" yaml:"sequence"`
|
|
}
|
|
|
|
// StdSignBytes returns the bytes to sign for a transaction.
|
|
func StdSignBytes(chainID string, accnum uint64, sequence uint64, fee StdFee, msgs []sdk.Msg, memo string) []byte {
|
|
msgsBytes := make([]json.RawMessage, 0, len(msgs))
|
|
for _, msg := range msgs {
|
|
msgsBytes = append(msgsBytes, json.RawMessage(msg.GetSignBytes()))
|
|
}
|
|
|
|
bz, err := codec.Cdc.MarshalJSON(StdSignDoc{
|
|
AccountNumber: accnum,
|
|
ChainID: chainID,
|
|
Fee: json.RawMessage(fee.Bytes()),
|
|
Memo: memo,
|
|
Msgs: msgsBytes,
|
|
Sequence: sequence,
|
|
})
|
|
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return sdk.MustSortJSON(bz)
|
|
}
|
|
|
|
// StdSignature represents a sig
|
|
type StdSignature struct {
|
|
crypto.PubKey `json:"pub_key" yaml:"pub_key"` // optional
|
|
Signature []byte `json:"signature" yaml:"signature"`
|
|
}
|
|
|
|
// DefaultTxDecoder logic for standard transaction decoding
|
|
func DefaultTxDecoder(cdc *codec.Codec) sdk.TxDecoder {
|
|
return func(txBytes []byte) (sdk.Tx, error) {
|
|
var tx = StdTx{}
|
|
|
|
if len(txBytes) == 0 {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "tx bytes are empty")
|
|
}
|
|
|
|
// StdTx.Msg is an interface. The concrete types
|
|
// are registered by MakeTxCodec
|
|
err := cdc.UnmarshalBinaryLengthPrefixed(txBytes, &tx)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error())
|
|
}
|
|
|
|
return tx, nil
|
|
}
|
|
}
|
|
|
|
// DefaultTxEncoder logic for standard transaction encoding
|
|
func DefaultTxEncoder(cdc *codec.Codec) sdk.TxEncoder {
|
|
return func(tx sdk.Tx) ([]byte, error) {
|
|
return cdc.MarshalBinaryLengthPrefixed(tx)
|
|
}
|
|
}
|
|
|
|
// MarshalYAML returns the YAML representation of the signature.
|
|
func (ss StdSignature) MarshalYAML() (interface{}, error) {
|
|
var (
|
|
bz []byte
|
|
pubkey string
|
|
err error
|
|
)
|
|
|
|
if ss.PubKey != nil {
|
|
pubkey, err = sdk.Bech32ifyPubKey(sdk.Bech32PubKeyTypeAccPub, ss.PubKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
bz, err = yaml.Marshal(struct {
|
|
PubKey string
|
|
Signature string
|
|
}{
|
|
PubKey: pubkey,
|
|
Signature: fmt.Sprintf("%s", ss.Signature),
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return string(bz), err
|
|
}
|