293 lines
8.0 KiB
Go
293 lines
8.0 KiB
Go
package state
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
|
|
"github.com/tendermint/basecoin/types"
|
|
. "github.com/tendermint/go-common"
|
|
"github.com/tendermint/go-events"
|
|
tmsp "github.com/tendermint/tmsp/types"
|
|
)
|
|
|
|
// If the tx is invalid, a TMSP error will be returned.
|
|
func ExecTx(state *State, tx types.Tx, isCheckTx bool, evc events.Fireable) tmsp.Result {
|
|
|
|
// TODO: do something with fees
|
|
fees := int64(0)
|
|
|
|
// Exec tx
|
|
switch tx := tx.(type) {
|
|
case *types.SendTx:
|
|
// First, get inputs
|
|
accounts, res := getInputs(state, tx.Inputs)
|
|
if res.IsErr() {
|
|
return res
|
|
}
|
|
|
|
// Then, get or make outputs.
|
|
accounts, res = getOrMakeOutputs(state, accounts, tx.Outputs)
|
|
if res.IsErr() {
|
|
return res
|
|
}
|
|
|
|
// Validate inputs and outputs
|
|
signBytes := tx.SignBytes(state.GetChainID())
|
|
inTotal, res := validateInputs(state, accounts, signBytes, tx.Inputs)
|
|
if res.IsErr() {
|
|
return res
|
|
}
|
|
outTotal, res := validateOutputs(tx.Outputs)
|
|
if res.IsErr() {
|
|
return res
|
|
}
|
|
if outTotal > inTotal {
|
|
return tmsp.ErrBaseInsufficientFunds
|
|
}
|
|
fee := inTotal - outTotal
|
|
fees += fee
|
|
|
|
// TODO: Fee validation for SendTx
|
|
|
|
// Good! Adjust accounts
|
|
adjustByInputs(state, accounts, tx.Inputs, isCheckTx)
|
|
adjustByOutputs(state, accounts, tx.Outputs, isCheckTx)
|
|
|
|
/*
|
|
// Fire events
|
|
if !isCheckTx {
|
|
if evc != nil {
|
|
for _, i := range tx.Inputs {
|
|
evc.FireEvent(types.EventStringAccInput(i.Address), types.EventDataTx{tx, nil, ""})
|
|
}
|
|
for _, o := range tx.Outputs {
|
|
evc.FireEvent(types.EventStringAccOutput(o.Address), types.EventDataTx{tx, nil, ""})
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
return tmsp.OK
|
|
|
|
case *types.CallTx:
|
|
// First, get input account
|
|
inAcc := state.GetAccount(tx.Input.Address)
|
|
if inAcc == nil {
|
|
log.Info(Fmt("Can't find in account %X", tx.Input.Address))
|
|
return tmsp.ErrBaseInvalidAddress
|
|
}
|
|
|
|
// Validate input
|
|
// pubKey should be present in either "inAcc" or "tx.Input"
|
|
if res := checkInputPubKey(tx.Input.Address, inAcc, tx.Input); res.IsErr() {
|
|
log.Info(Fmt("Can't find pubkey for %X", tx.Input.Address))
|
|
return res
|
|
}
|
|
signBytes := tx.SignBytes(state.GetChainID())
|
|
res := validateInput(state, inAcc, signBytes, tx.Input)
|
|
if res.IsErr() {
|
|
log.Info(Fmt("validateInput failed on %X: %v", tx.Input.Address, res))
|
|
return res
|
|
}
|
|
if tx.Input.Amount < tx.Fee {
|
|
log.Info(Fmt("Sender did not send enough to cover the fee %X", tx.Input.Address))
|
|
return tmsp.ErrBaseInsufficientFunds
|
|
}
|
|
|
|
// Validate call address
|
|
if strings.HasPrefix(string(tx.Address), "gov/") {
|
|
// This is a gov call.
|
|
} else {
|
|
return tmsp.ErrBaseInvalidAddress.AppendLog(Fmt("Unrecognized address %X", tx.Address))
|
|
}
|
|
|
|
// Good!
|
|
value := tx.Input.Amount - tx.Fee
|
|
inAcc.Sequence += 1
|
|
inAcc.Balance -= tx.Input.Amount
|
|
state.SetCheckAccount(tx.Input.Address, inAcc.Sequence, inAcc.Balance)
|
|
|
|
// If this is AppendTx, actually save accounts
|
|
if !isCheckTx {
|
|
state.SetAccount(inAcc)
|
|
// NOTE: value is dangling.
|
|
// XXX: don't just give it back
|
|
inAcc.Balance += value
|
|
// TODO: logic.
|
|
// TODO: persist
|
|
// state.SetAccount(inAcc)
|
|
log.Info("Successful execution")
|
|
// Fire events
|
|
/*
|
|
if evc != nil {
|
|
exception := ""
|
|
if res.IsErr() {
|
|
exception = res.Error()
|
|
}
|
|
evc.FireEvent(types.EventStringAccInput(tx.Input.Address), types.EventDataTx{tx, ret, exception})
|
|
evc.FireEvent(types.EventStringAccOutput(tx.Address), types.EventDataTx{tx, ret, exception})
|
|
}
|
|
*/
|
|
}
|
|
|
|
return tmsp.OK
|
|
|
|
default:
|
|
return tmsp.ErrBaseEncodingError.SetLog("Unknown tx type")
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
// The accounts from the TxInputs must either already have
|
|
// crypto.PubKey.(type) != nil, (it must be known),
|
|
// or it must be specified in the TxInput. If redeclared,
|
|
// the TxInput is modified and input.PubKey set to nil.
|
|
func getInputs(state types.AccountGetter, ins []types.TxInput) (map[string]*types.Account, tmsp.Result) {
|
|
accounts := map[string]*types.Account{}
|
|
for _, in := range ins {
|
|
// Account shouldn't be duplicated
|
|
if _, ok := accounts[string(in.Address)]; ok {
|
|
return nil, tmsp.ErrBaseDuplicateAddress
|
|
}
|
|
acc := state.GetAccount(in.Address)
|
|
if acc == nil {
|
|
return nil, tmsp.ErrBaseInvalidAddress
|
|
}
|
|
// PubKey should be present in either "account" or "in"
|
|
if res := checkInputPubKey(in.Address, acc, in); res.IsErr() {
|
|
return nil, res
|
|
}
|
|
accounts[string(in.Address)] = acc
|
|
}
|
|
return accounts, tmsp.OK
|
|
}
|
|
|
|
func getOrMakeOutputs(state types.AccountGetter, accounts map[string]*types.Account, outs []types.TxOutput) (map[string]*types.Account, tmsp.Result) {
|
|
if accounts == nil {
|
|
accounts = make(map[string]*types.Account)
|
|
}
|
|
|
|
for _, out := range outs {
|
|
// Account shouldn't be duplicated
|
|
if _, ok := accounts[string(out.Address)]; ok {
|
|
return nil, tmsp.ErrBaseDuplicateAddress
|
|
}
|
|
acc := state.GetAccount(out.Address)
|
|
// output account may be nil (new)
|
|
if acc == nil {
|
|
acc = &types.Account{
|
|
PubKey: nil,
|
|
Sequence: 0,
|
|
Balance: 0,
|
|
}
|
|
}
|
|
accounts[string(out.Address)] = acc
|
|
}
|
|
return accounts, tmsp.OK
|
|
}
|
|
|
|
// Input must not have a redundant PubKey (i.e. Account already has PubKey).
|
|
// NOTE: Account has PubKey if Sequence > 0
|
|
func checkInputPubKey(address []byte, acc *types.Account, in types.TxInput) tmsp.Result {
|
|
if acc.PubKey == nil {
|
|
if in.PubKey == nil {
|
|
return tmsp.ErrBaseUnknownPubKey
|
|
}
|
|
if !bytes.Equal(in.PubKey.Address(), address) {
|
|
return tmsp.ErrBaseInvalidPubKey
|
|
}
|
|
acc.PubKey = in.PubKey
|
|
} else {
|
|
if in.PubKey != nil {
|
|
return tmsp.ErrBaseInvalidPubKey
|
|
}
|
|
}
|
|
return tmsp.OK
|
|
}
|
|
|
|
// Validate inputs and compute total amount
|
|
func validateInputs(state *State, accounts map[string]*types.Account, signBytes []byte, ins []types.TxInput) (total int64, res tmsp.Result) {
|
|
|
|
for _, in := range ins {
|
|
acc := accounts[string(in.Address)]
|
|
if acc == nil {
|
|
PanicSanity("validateInputs() expects account in accounts")
|
|
}
|
|
res = validateInput(state, acc, signBytes, in)
|
|
if res.IsErr() {
|
|
return
|
|
}
|
|
// Good. Add amount to total
|
|
total += in.Amount
|
|
}
|
|
return total, tmsp.OK
|
|
}
|
|
|
|
func validateInput(state *State, acc *types.Account, signBytes []byte, in types.TxInput) (res tmsp.Result) {
|
|
// Check TxInput basic
|
|
if res := in.ValidateBasic(); res.IsErr() {
|
|
return res
|
|
}
|
|
// Check sequence/balance
|
|
seq, balance := state.GetCheckAccount(in.Address, acc.Sequence, acc.Balance)
|
|
if seq+1 != in.Sequence {
|
|
return tmsp.ErrBaseInvalidSequence.AppendLog(Fmt("Got %v, expected %v. (acc.seq=%v)", in.Sequence, seq+1, acc.Sequence))
|
|
}
|
|
// Check amount
|
|
if balance < in.Amount {
|
|
return tmsp.ErrBaseInsufficientFunds
|
|
}
|
|
// Check signatures
|
|
if !acc.PubKey.VerifyBytes(signBytes, in.Signature) {
|
|
return tmsp.ErrBaseInvalidSignature
|
|
}
|
|
return tmsp.OK
|
|
}
|
|
|
|
func validateOutputs(outs []types.TxOutput) (total int64, res tmsp.Result) {
|
|
for _, out := range outs {
|
|
// Check TxOutput basic
|
|
if res := out.ValidateBasic(); res.IsErr() {
|
|
return 0, res
|
|
}
|
|
// Good. Add amount to total
|
|
total += out.Amount
|
|
}
|
|
return total, tmsp.OK
|
|
}
|
|
|
|
func adjustByInputs(state *State, accounts map[string]*types.Account, ins []types.TxInput, isCheckTx bool) {
|
|
for _, in := range ins {
|
|
acc := accounts[string(in.Address)]
|
|
if acc == nil {
|
|
PanicSanity("adjustByInputs() expects account in accounts")
|
|
}
|
|
if acc.Balance < in.Amount {
|
|
PanicSanity("adjustByInputs() expects sufficient funds")
|
|
}
|
|
acc.Balance -= in.Amount
|
|
acc.Sequence += 1
|
|
state.SetCheckAccount(in.Address, acc.Sequence, acc.Balance)
|
|
if !isCheckTx {
|
|
// NOTE: Must be set in deterministic order
|
|
state.SetAccount(acc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func adjustByOutputs(state *State, accounts map[string]*types.Account, outs []types.TxOutput, isCheckTx bool) {
|
|
for _, out := range outs {
|
|
acc := accounts[string(out.Address)]
|
|
if acc == nil {
|
|
PanicSanity("adjustByOutputs() expects account in accounts")
|
|
}
|
|
acc.Balance += out.Amount
|
|
if !isCheckTx {
|
|
state.SetCheckAccount(out.Address, acc.Sequence, acc.Balance)
|
|
// NOTE: Must be set in deterministic order
|
|
state.SetAccount(acc)
|
|
}
|
|
}
|
|
}
|