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

Make it all compile with new Deliver/CheckTx

This commit is contained in:
Ethan Frey 2017-07-30 11:45:08 -04:00
parent cb4277f4b7
commit cbfd2cd611
22 changed files with 193 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/guide/counter/plugins/counter/counter.go
View File

@ -128,13 +128,13 @@ func (Handler) Name() string {
func (Handler) AssertDispatcher() {} func (Handler) AssertDispatcher() {}
// CheckTx checks if the tx is properly structured // CheckTx checks if the tx is properly structured
func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, _ basecoin.Checker) (res basecoin.Result, err error) { func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, _ basecoin.Checker) (res basecoin.CheckResult, err error) {
_, err = checkTx(ctx, tx) _, err = checkTx(ctx, tx)
return return
} }
// DeliverTx executes the tx if valid // DeliverTx executes the tx if valid
func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, dispatch basecoin.Deliver) (res basecoin.Result, err error) { func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, dispatch basecoin.Deliver) (res basecoin.DeliverResult, err error) {
ctr, err := checkTx(ctx, tx) ctr, err := checkTx(ctx, tx)
if err != nil { if err != nil {
return res, err return res, err

4
modules/auth/signature.go
View File

@ -39,7 +39,7 @@ type Signable interface {
} }
// CheckTx verifies the signatures are correct - fulfills Middlware interface // CheckTx verifies the signatures are correct - fulfills Middlware interface
func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
sigs, tnext, err := getSigners(tx) sigs, tnext, err := getSigners(tx)
if err != nil { if err != nil {
return res, err return res, err
@ -49,7 +49,7 @@ func (Signatures) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoi
} }
// DeliverTx verifies the signatures are correct - fulfills Middlware interface // DeliverTx verifies the signatures are correct - fulfills Middlware interface
func (Signatures) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (Signatures) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
sigs, tnext, err := getSigners(tx) sigs, tnext, err := getSigners(tx)
if err != nil { if err != nil {
return res, err return res, err

4
modules/base/chain.go
View File

@ -24,7 +24,7 @@ func (Chain) Name() string {
var _ stack.Middleware = Chain{} var _ stack.Middleware = Chain{}
// CheckTx makes sure we are on the proper chain - fulfills Middlware interface // CheckTx makes sure we are on the proper chain - fulfills Middlware interface
func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx) stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
if err != nil { if err != nil {
return res, err return res, err
@ -33,7 +33,7 @@ func (c Chain) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.T
} }
// DeliverTx makes sure we are on the proper chain - fulfills Middlware interface // DeliverTx makes sure we are on the proper chain - fulfills Middlware interface
func (c Chain) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (c Chain) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx) stx, err := c.checkChainTx(ctx.ChainID(), ctx.BlockHeight(), tx)
if err != nil { if err != nil {
return res, err return res, err

4
modules/base/logger.go
View File

@ -26,7 +26,7 @@ func (Logger) Name() string {
var _ stack.Middleware = Logger{} var _ stack.Middleware = Logger{}
// CheckTx logs time and result - fulfills Middlware interface // CheckTx logs time and result - fulfills Middlware interface
func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
start := time.Now() start := time.Now()
res, err = next.CheckTx(ctx, store, tx) res, err = next.CheckTx(ctx, store, tx)
delta := time.Now().Sub(start) delta := time.Now().Sub(start)
@ -41,7 +41,7 @@ func (Logger) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx
} }
// DeliverTx logs time and result - fulfills Middlware interface // DeliverTx logs time and result - fulfills Middlware interface
func (Logger) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (Logger) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
start := time.Now() start := time.Now()
res, err = next.DeliverTx(ctx, store, tx) res, err = next.DeliverTx(ctx, store, tx)
delta := time.Now().Sub(start) delta := time.Now().Sub(start)

122
modules/base/multiplexer.go
View File

@ -1,73 +1,73 @@
package base package base
import ( // import (
"strings" // "strings"
wire "github.com/tendermint/go-wire" // wire "github.com/tendermint/go-wire"
"github.com/tendermint/go-wire/data" // "github.com/tendermint/go-wire/data"
"github.com/tendermint/basecoin" // "github.com/tendermint/basecoin"
"github.com/tendermint/basecoin/stack" // "github.com/tendermint/basecoin/stack"
"github.com/tendermint/basecoin/state" // "github.com/tendermint/basecoin/state"
) // )
//nolint // //nolint
const ( // const (
NameMultiplexer = "mplx" // NameMultiplexer = "mplx"
) // )
// Multiplexer grabs a MultiTx and sends them sequentially down the line // // Multiplexer grabs a MultiTx and sends them sequentially down the line
type Multiplexer struct { // type Multiplexer struct {
stack.PassOption // stack.PassOption
} // }
// Name of the module - fulfills Middleware interface // // Name of the module - fulfills Middleware interface
func (Multiplexer) Name() string { // func (Multiplexer) Name() string {
return NameMultiplexer // return NameMultiplexer
} // }
var _ stack.Middleware = Multiplexer{} // var _ stack.Middleware = Multiplexer{}
// CheckTx splits the input tx and checks them all - fulfills Middlware interface // // CheckTx splits the input tx and checks them all - fulfills Middlware interface
func (Multiplexer) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { // func (Multiplexer) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
if mtx, ok := tx.Unwrap().(*MultiTx); ok { // if mtx, ok := tx.Unwrap().(*MultiTx); ok {
return runAll(ctx, store, mtx.Txs, next.CheckTx) // return runAll(ctx, store, mtx.Txs, next.CheckTx)
} // }
return next.CheckTx(ctx, store, tx) // return next.CheckTx(ctx, store, tx)
} // }
// DeliverTx splits the input tx and checks them all - fulfills Middlware interface // // DeliverTx splits the input tx and checks them all - fulfills Middlware interface
func (Multiplexer) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { // func (Multiplexer) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
if mtx, ok := tx.Unwrap().(*MultiTx); ok { // if mtx, ok := tx.Unwrap().(*MultiTx); ok {
return runAll(ctx, store, mtx.Txs, next.DeliverTx) // return runAll(ctx, store, mtx.Txs, next.DeliverTx)
} // }
return next.DeliverTx(ctx, store, tx) // return next.DeliverTx(ctx, store, tx)
} // }
func runAll(ctx basecoin.Context, store state.SimpleDB, txs []basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) { // func runAll(ctx basecoin.Context, store state.SimpleDB, txs []basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) {
// store all results, unless anything errors // // store all results, unless anything errors
rs := make([]basecoin.Result, len(txs)) // rs := make([]basecoin.Result, len(txs))
for i, stx := range txs { // for i, stx := range txs {
rs[i], err = next(ctx, store, stx) // rs[i], err = next(ctx, store, stx)
if err != nil { // if err != nil {
return // return
} // }
} // }
// now combine the results into one... // // now combine the results into one...
return combine(rs), nil // return combine(rs), nil
} // }
// combines all data bytes as a go-wire array. // // combines all data bytes as a go-wire array.
// joins all log messages with \n // // joins all log messages with \n
func combine(all []basecoin.Result) basecoin.Result { // func combine(all []basecoin.Result) basecoin.Result {
datas := make([]data.Bytes, len(all)) // datas := make([]data.Bytes, len(all))
logs := make([]string, len(all)) // logs := make([]string, len(all))
for i, r := range all { // for i, r := range all {
datas[i] = r.Data // datas[i] = r.Data
logs[i] = r.Log // logs[i] = r.Log
} // }
return basecoin.Result{ // return basecoin.Result{
Data: wire.BinaryBytes(datas), // Data: wire.BinaryBytes(datas),
Log: strings.Join(logs, "\n"), // Log: strings.Join(logs, "\n"),
} // }
} // }

4
modules/base/tx.go
View File

@ -16,13 +16,13 @@ const (
//nolint //nolint
const ( const (
TypeMultiTx = NameMultiplexer + "/tx" // TypeMultiTx = NameMultiplexer + "/tx"
TypeChainTx = NameChain + "/tx" TypeChainTx = NameChain + "/tx"
) )
func init() { func init() {
basecoin.TxMapper. basecoin.TxMapper.
RegisterImplementation(MultiTx{}, TypeMultiTx, ByteMultiTx). // RegisterImplementation(MultiTx{}, TypeMultiTx, ByteMultiTx).
RegisterImplementation(ChainTx{}, TypeChainTx, ByteChainTx) RegisterImplementation(ChainTx{}, TypeChainTx, ByteChainTx)
} }

38
modules/coin/handler.go
View File

@ -35,7 +35,7 @@ func (Handler) AssertDispatcher() {}
// CheckTx checks if there is enough money in the account // CheckTx checks if there is enough money in the account
func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, _ basecoin.Checker) (res basecoin.Result, err error) { tx basecoin.Tx, _ basecoin.Checker) (res basecoin.CheckResult, err error) {
err = tx.ValidateBasic() err = tx.ValidateBasic()
if err != nil { if err != nil {
@ -46,14 +46,14 @@ func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB,
case SendTx: case SendTx:
return res, h.checkSendTx(ctx, store, t) return res, h.checkSendTx(ctx, store, t)
case CreditTx: case CreditTx:
return h.creditTx(ctx, store, t) return res, h.creditTx(ctx, store, t)
} }
return res, errors.ErrUnknownTxType(tx.Unwrap()) return res, errors.ErrUnknownTxType(tx.Unwrap())
} }
// DeliverTx moves the money // DeliverTx moves the money
func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, cb basecoin.Deliver) (res basecoin.Result, err error) { tx basecoin.Tx, cb basecoin.Deliver) (res basecoin.DeliverResult, err error) {
err = tx.ValidateBasic() err = tx.ValidateBasic()
if err != nil { if err != nil {
@ -62,9 +62,9 @@ func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
switch t := tx.Unwrap().(type) { switch t := tx.Unwrap().(type) {
case SendTx: case SendTx:
return h.sendTx(ctx, store, t, cb) return res, h.sendTx(ctx, store, t, cb)
case CreditTx: case CreditTx:
return h.creditTx(ctx, store, t) return res, h.creditTx(ctx, store, t)
} }
return res, errors.ErrUnknownTxType(tx.Unwrap()) return res, errors.ErrUnknownTxType(tx.Unwrap())
} }
@ -85,11 +85,11 @@ func (h Handler) SetOption(l log.Logger, store state.SimpleDB,
} }
func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB, func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
send SendTx, cb basecoin.Deliver) (res basecoin.Result, err error) { send SendTx, cb basecoin.Deliver) error {
err = checkTx(ctx, send) err := checkTx(ctx, send)
if err != nil { if err != nil {
return res, err return err
} }
// deduct from all input accounts // deduct from all input accounts
@ -97,7 +97,7 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
for _, in := range send.Inputs { for _, in := range send.Inputs {
_, err = ChangeCoins(store, in.Address, in.Coins.Negative()) _, err = ChangeCoins(store, in.Address, in.Coins.Negative())
if err != nil { if err != nil {
return res, err return err
} }
senders = append(senders, in.Address) senders = append(senders, in.Address)
} }
@ -112,7 +112,7 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
_, err = ChangeCoins(store, out.Address, out.Coins) _, err = ChangeCoins(store, out.Address, out.Coins)
if err != nil { if err != nil {
return res, err return err
} }
// now send ibc packet if needed... // now send ibc packet if needed...
if out.Address.ChainID != "" { if out.Address.ChainID != "" {
@ -133,46 +133,46 @@ func (h Handler) sendTx(ctx basecoin.Context, store state.SimpleDB,
ibcCtx := ctx.WithPermissions(ibc.AllowIBC(NameCoin)) ibcCtx := ctx.WithPermissions(ibc.AllowIBC(NameCoin))
_, err := cb.DeliverTx(ibcCtx, store, packet.Wrap()) _, err := cb.DeliverTx(ibcCtx, store, packet.Wrap())
if err != nil { if err != nil {
return res, err return err
} }
} }
} }
// a-ok! // a-ok!
return res, nil return nil
} }
func (h Handler) creditTx(ctx basecoin.Context, store state.SimpleDB, func (h Handler) creditTx(ctx basecoin.Context, store state.SimpleDB,
credit CreditTx) (res basecoin.Result, err error) { credit CreditTx) error {
// first check permissions!! // first check permissions!!
info, err := loadHandlerInfo(store) info, err := loadHandlerInfo(store)
if err != nil { if err != nil {
return res, err return err
} }
if info.Issuer.Empty() || !ctx.HasPermission(info.Issuer) { if info.Issuer.Empty() || !ctx.HasPermission(info.Issuer) {
return res, errors.ErrUnauthorized() return errors.ErrUnauthorized()
} }
// load up the account // load up the account
addr := ChainAddr(credit.Debitor) addr := ChainAddr(credit.Debitor)
acct, err := GetAccount(store, addr) acct, err := GetAccount(store, addr)
if err != nil { if err != nil {
return res, err return err
} }
// make and check changes // make and check changes
acct.Coins = acct.Coins.Plus(credit.Credit) acct.Coins = acct.Coins.Plus(credit.Credit)
if !acct.Coins.IsNonnegative() { if !acct.Coins.IsNonnegative() {
return res, ErrInsufficientFunds() return ErrInsufficientFunds()
} }
acct.Credit = acct.Credit.Plus(credit.Credit) acct.Credit = acct.Credit.Plus(credit.Credit)
if !acct.Credit.IsNonnegative() { if !acct.Credit.IsNonnegative() {
return res, ErrInsufficientCredit() return ErrInsufficientCredit()
} }
err = storeAccount(store, addr.Bytes(), acct) err = storeAccount(store, addr.Bytes(), acct)
return res, err return err
} }
func checkTx(ctx basecoin.Context, send SendTx) error { func checkTx(ctx basecoin.Context, send SendTx) error {

52
modules/fee/handler.go
View File

@ -45,40 +45,56 @@ func (SimpleFeeMiddleware) Name() string {
} }
// CheckTx - check the transaction // CheckTx - check the transaction
func (h SimpleFeeMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (h SimpleFeeMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
return h.doTx(ctx, store, tx, next.CheckTx) fee, err := h.verifyFee(ctx, tx)
if err != nil {
return res, err
}
if !fee.Fee.IsZero() { // now, try to make a IPC call to coins...
send := coin.NewSendOneTx(fee.Payer, h.Collector, coin.Coins{fee.Fee})
_, err = next.CheckTx(ctx, store, send)
if err != nil {
return res, err
}
}
return next.CheckTx(ctx, store, fee.Tx)
} }
// DeliverTx - send the fee handler transaction // DeliverTx - send the fee handler transaction
func (h SimpleFeeMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (h SimpleFeeMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
return h.doTx(ctx, store, tx, next.DeliverTx) fee, err := h.verifyFee(ctx, tx)
if err != nil {
return res, err
}
if !fee.Fee.IsZero() { // now, try to make a IPC call to coins...
send := coin.NewSendOneTx(fee.Payer, h.Collector, coin.Coins{fee.Fee})
_, err = next.DeliverTx(ctx, store, send)
if err != nil {
return res, err
}
}
return next.DeliverTx(ctx, store, fee.Tx)
} }
func (h SimpleFeeMiddleware) doTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.CheckerFunc) (res basecoin.Result, err error) { func (h SimpleFeeMiddleware) verifyFee(ctx basecoin.Context, tx basecoin.Tx) (Fee, error) {
feeTx, ok := tx.Unwrap().(Fee) feeTx, ok := tx.Unwrap().(Fee)
if !ok { if !ok {
// the fee wrapper is not required if there is no minimum // the fee wrapper is not required if there is no minimum
if h.MinFee.IsZero() { if h.MinFee.IsZero() {
return next(ctx, store, tx) return feeTx, nil
} }
return res, errors.ErrInvalidFormat(TypeFees, tx) return feeTx, errors.ErrInvalidFormat(TypeFees, tx)
} }
// see if it is the proper denom and big enough // see if it is the proper denom and big enough
fee := feeTx.Fee fee := feeTx.Fee
if fee.Denom != h.MinFee.Denom { if fee.Denom != h.MinFee.Denom {
return res, ErrWrongFeeDenom(h.MinFee.Denom) return feeTx, ErrWrongFeeDenom(h.MinFee.Denom)
} }
if !fee.IsGTE(h.MinFee) { if !fee.IsGTE(h.MinFee) {
return res, ErrInsufficientFees() return feeTx, ErrInsufficientFees()
} }
return feeTx, nil
// now, try to make a IPC call to coins...
send := coin.NewSendOneTx(feeTx.Payer, h.Collector, coin.Coins{fee})
_, err = next(ctx, store, send)
if err != nil {
return res, err
}
return next(ctx, store, feeTx.Tx)
} }

21
modules/ibc/handler.go
View File

@ -70,26 +70,27 @@ func (h Handler) SetOption(l log.Logger, store state.SimpleDB, module, key, valu
// CheckTx verifies the packet is formated correctly, and has the proper sequence // CheckTx verifies the packet is formated correctly, and has the proper sequence
// for a registered chain // for a registered chain
func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
err = tx.ValidateBasic() err = tx.ValidateBasic()
if err != nil { if err != nil {
return res, err return res, err
} }
switch t := tx.Unwrap().(type) { // TODO: better fee calculation (don't do complex crypto)
switch tx.Unwrap().(type) {
case RegisterChainTx: case RegisterChainTx:
return h.initSeed(ctx, store, t) return res, nil
case UpdateChainTx: case UpdateChainTx:
return h.updateSeed(ctx, store, t) return res, nil
case CreatePacketTx: case CreatePacketTx:
return h.createPacket(ctx, store, t) return res, nil
} }
return res, errors.ErrUnknownTxType(tx.Unwrap()) return res, errors.ErrUnknownTxType(tx.Unwrap())
} }
// DeliverTx verifies all signatures on the tx and updates the chain state // DeliverTx verifies all signatures on the tx and updates the chain state
// apropriately // apropriately
func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
err = tx.ValidateBasic() err = tx.ValidateBasic()
if err != nil { if err != nil {
return res, err return res, err
@ -111,7 +112,7 @@ func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx baseco
// //
// only the registrar, if set, is allowed to do this // only the registrar, if set, is allowed to do this
func (h Handler) initSeed(ctx basecoin.Context, store state.SimpleDB, func (h Handler) initSeed(ctx basecoin.Context, store state.SimpleDB,
t RegisterChainTx) (res basecoin.Result, err error) { t RegisterChainTx) (res basecoin.DeliverResult, err error) {
info := LoadInfo(store) info := LoadInfo(store)
if !info.Registrar.Empty() && !ctx.HasPermission(info.Registrar) { if !info.Registrar.Empty() && !ctx.HasPermission(info.Registrar) {
@ -135,7 +136,7 @@ func (h Handler) initSeed(ctx basecoin.Context, store state.SimpleDB,
// updateSeed checks the seed against the existing chain data and rejects it if it // updateSeed checks the seed against the existing chain data and rejects it if it
// doesn't fit (or no chain data) // doesn't fit (or no chain data)
func (h Handler) updateSeed(ctx basecoin.Context, store state.SimpleDB, func (h Handler) updateSeed(ctx basecoin.Context, store state.SimpleDB,
t UpdateChainTx) (res basecoin.Result, err error) { t UpdateChainTx) (res basecoin.DeliverResult, err error) {
chainID := t.ChainID() chainID := t.ChainID()
s := NewChainSet(store) s := NewChainSet(store)
@ -165,7 +166,7 @@ func (h Handler) updateSeed(ctx basecoin.Context, store state.SimpleDB,
// createPacket makes sure all permissions are good and the destination // createPacket makes sure all permissions are good and the destination
// chain is registed. If so, it appends it to the outgoing queue // chain is registed. If so, it appends it to the outgoing queue
func (h Handler) createPacket(ctx basecoin.Context, store state.SimpleDB, func (h Handler) createPacket(ctx basecoin.Context, store state.SimpleDB,
t CreatePacketTx) (res basecoin.Result, err error) { t CreatePacketTx) (res basecoin.DeliverResult, err error) {
// make sure the chain is registed // make sure the chain is registed
dest := t.DestChain dest := t.DestChain
@ -203,6 +204,6 @@ func (h Handler) createPacket(ctx basecoin.Context, store state.SimpleDB,
packet.Sequence = q.Tail() packet.Sequence = q.Tail()
q.Push(packet.Bytes()) q.Push(packet.Bytes())
res = basecoin.Result{Log: fmt.Sprintf("Packet %s %d", dest, packet.Sequence)} res = basecoin.DeliverResult{Log: fmt.Sprintf("Packet %s %d", dest, packet.Sequence)}
return return
} }

4
modules/ibc/middleware.go
View File

@ -26,7 +26,7 @@ func (Middleware) Name() string {
// CheckTx verifies the named chain and height is present, and verifies // CheckTx verifies the named chain and height is present, and verifies
// the merkle proof in the packet // the merkle proof in the packet
func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
// if it is not a PostPacket, just let it go through // if it is not a PostPacket, just let it go through
post, ok := tx.Unwrap().(PostPacketTx) post, ok := tx.Unwrap().(PostPacketTx)
if !ok { if !ok {
@ -43,7 +43,7 @@ func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
// DeliverTx verifies the named chain and height is present, and verifies // DeliverTx verifies the named chain and height is present, and verifies
// the merkle proof in the packet // the merkle proof in the packet
func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
// if it is not a PostPacket, just let it go through // if it is not a PostPacket, just let it go through
post, ok := tx.Unwrap().(PostPacketTx) post, ok := tx.Unwrap().(PostPacketTx)
if !ok { if !ok {

2
modules/ibc/test_helpers.go
View File

@ -100,7 +100,7 @@ func (a *AppChain) IncrementHeight(delta int) int {
// DeliverTx runs the tx and commits the new tree, incrementing height // DeliverTx runs the tx and commits the new tree, incrementing height
// by one. // by one.
func (a *AppChain) DeliverTx(tx basecoin.Tx, perms ...basecoin.Actor) (basecoin.Result, error) { func (a *AppChain) DeliverTx(tx basecoin.Tx, perms ...basecoin.Actor) (basecoin.DeliverResult, error) {
ctx := stack.MockContext(a.chainID, uint64(a.height)).WithPermissions(perms...) ctx := stack.MockContext(a.chainID, uint64(a.height)).WithPermissions(perms...)
store := a.store.Checkpoint() store := a.store.Checkpoint()
res, err := a.app.DeliverTx(ctx, store, tx) res, err := a.app.DeliverTx(ctx, store, tx)

4
modules/nonce/replaycheck.go
View File

@ -25,7 +25,7 @@ var _ stack.Middleware = ReplayCheck{}
// CheckTx verifies tx is not being replayed - fulfills Middlware interface // CheckTx verifies tx is not being replayed - fulfills Middlware interface
func (r ReplayCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB, func (r ReplayCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
stx, err := r.checkIncrementNonceTx(ctx, store, tx) stx, err := r.checkIncrementNonceTx(ctx, store, tx)
if err != nil { if err != nil {
@ -39,7 +39,7 @@ func (r ReplayCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
// NOTE It is okay to modify the sequence before running the wrapped TX because if the // NOTE It is okay to modify the sequence before running the wrapped TX because if the
// wrapped Tx fails, the state changes are not applied // wrapped Tx fails, the state changes are not applied
func (r ReplayCheck) DeliverTx(ctx basecoin.Context, store state.SimpleDB, func (r ReplayCheck) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
stx, err := r.checkIncrementNonceTx(ctx, store, tx) stx, err := r.checkIncrementNonceTx(ctx, store, tx)
if err != nil { if err != nil {

4
modules/roles/handler.go
View File

@ -27,7 +27,7 @@ func (Handler) Name() string {
} }
// CheckTx verifies if the transaction is properly formated // CheckTx verifies if the transaction is properly formated
func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
var cr CreateRoleTx var cr CreateRoleTx
cr, err = checkTx(ctx, tx) cr, err = checkTx(ctx, tx)
if err != nil { if err != nil {
@ -40,7 +40,7 @@ func (h Handler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin
// DeliverTx tries to create a new role. // DeliverTx tries to create a new role.
// //
// Returns an error if the role already exists // Returns an error if the role already exists
func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (h Handler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
create, err := checkTx(ctx, tx) create, err := checkTx(ctx, tx)
if err != nil { if err != nil {
return res, err return res, err

4
modules/roles/middleware.go
View File

@ -27,7 +27,7 @@ func (Middleware) Name() string {
// CheckTx tries to assume the named role if requested. // CheckTx tries to assume the named role if requested.
// If no role is requested, do nothing. // If no role is requested, do nothing.
// If insufficient authority to assume the role, return error. // If insufficient authority to assume the role, return error.
func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
// if this is not an AssumeRoleTx, then continue // if this is not an AssumeRoleTx, then continue
assume, ok := tx.Unwrap().(AssumeRoleTx) assume, ok := tx.Unwrap().(AssumeRoleTx)
if !ok { // this also breaks the recursion below if !ok { // this also breaks the recursion below
@ -46,7 +46,7 @@ func (m Middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
// DeliverTx tries to assume the named role if requested. // DeliverTx tries to assume the named role if requested.
// If no role is requested, do nothing. // If no role is requested, do nothing.
// If insufficient authority to assume the role, return error. // If insufficient authority to assume the role, return error.
func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (m Middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
// if this is not an AssumeRoleTx, then continue // if this is not an AssumeRoleTx, then continue
assume, ok := tx.Unwrap().(AssumeRoleTx) assume, ok := tx.Unwrap().(AssumeRoleTx)
if !ok { // this also breaks the recursion below if !ok { // this also breaks the recursion below

4
stack/checkpoint.go
View File

@ -25,7 +25,7 @@ func (Checkpoint) Name() string {
var _ Middleware = Checkpoint{} var _ Middleware = Checkpoint{}
// CheckTx reverts all data changes if there was an error // CheckTx reverts all data changes if there was an error
func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
if !c.OnCheck { if !c.OnCheck {
return next.CheckTx(ctx, store, tx) return next.CheckTx(ctx, store, tx)
} }
@ -38,7 +38,7 @@ func (c Checkpoint) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basec
} }
// DeliverTx reverts all data changes if there was an error // DeliverTx reverts all data changes if there was an error
func (c Checkpoint) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (c Checkpoint) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
if !c.OnDeliver { if !c.OnDeliver {
return next.DeliverTx(ctx, store, tx) return next.DeliverTx(ctx, store, tx)
} }

4
stack/context.go
View File

@ -104,7 +104,7 @@ func withIBC(ctx basecoin.Context) basecoin.Context {
} }
func secureCheck(h basecoin.Checker, parent basecoin.Context) basecoin.Checker { func secureCheck(h basecoin.Checker, parent basecoin.Context) basecoin.Checker {
next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
if !parent.IsParent(ctx) { if !parent.IsParent(ctx) {
return res, errors.New("Passing in non-child Context") return res, errors.New("Passing in non-child Context")
} }
@ -114,7 +114,7 @@ func secureCheck(h basecoin.Checker, parent basecoin.Context) basecoin.Checker {
} }
func secureDeliver(h basecoin.Deliver, parent basecoin.Context) basecoin.Deliver { func secureDeliver(h basecoin.Deliver, parent basecoin.Context) basecoin.Deliver {
next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { next := func(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
if !parent.IsParent(ctx) { if !parent.IsParent(ctx) {
return res, errors.New("Passing in non-child Context") return res, errors.New("Passing in non-child Context")
} }

4
stack/dispatcher.go
View File

@ -64,7 +64,7 @@ func (d *Dispatcher) Name() string {
// Tries to find a registered module (Dispatchable) based on the name of the tx. // Tries to find a registered module (Dispatchable) based on the name of the tx.
// The tx name (as registered with go-data) should be in the form `<module name>/XXXX`, // The tx name (as registered with go-data) should be in the form `<module name>/XXXX`,
// where `module name` must match the name of a dispatchable and XXX can be any string. // where `module name` must match the name of a dispatchable and XXX can be any string.
func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
r, err := d.lookupTx(tx) r, err := d.lookupTx(tx)
if err != nil { if err != nil {
return res, err return res, err
@ -85,7 +85,7 @@ func (d *Dispatcher) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx base
// Tries to find a registered module (Dispatchable) based on the name of the tx. // Tries to find a registered module (Dispatchable) based on the name of the tx.
// The tx name (as registered with go-data) should be in the form `<module name>/XXXX`, // The tx name (as registered with go-data) should be in the form `<module name>/XXXX`,
// where `module name` must match the name of a dispatchable and XXX can be any string. // where `module name` must match the name of a dispatchable and XXX can be any string.
func (d *Dispatcher) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (d *Dispatcher) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
r, err := d.lookupTx(tx) r, err := d.lookupTx(tx)
if err != nil { if err != nil {
return res, err return res, err

41
stack/helpers.go
View File

@ -105,13 +105,13 @@ func (OKHandler) Name() string {
} }
// CheckTx always returns an empty success tx // CheckTx always returns an empty success tx
func (ok OKHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (ok OKHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
return basecoin.Result{Log: ok.Log}, nil return basecoin.CheckResult{Log: ok.Log}, nil
} }
// DeliverTx always returns an empty success tx // DeliverTx always returns an empty success tx
func (ok OKHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (ok OKHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
return basecoin.Result{Log: ok.Log}, nil return basecoin.DeliverResult{Log: ok.Log}, nil
} }
// EchoHandler returns success, echoing res.Data = tx bytes // EchoHandler returns success, echoing res.Data = tx bytes
@ -127,15 +127,15 @@ func (EchoHandler) Name() string {
} }
// CheckTx always returns an empty success tx // CheckTx always returns an empty success tx
func (EchoHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (EchoHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
data, err := data.ToWire(tx) data, err := data.ToWire(tx)
return basecoin.Result{Data: data}, err return basecoin.CheckResult{Data: data}, err
} }
// DeliverTx always returns an empty success tx // DeliverTx always returns an empty success tx
func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
data, err := data.ToWire(tx) data, err := data.ToWire(tx)
return basecoin.Result{Data: data}, err return basecoin.DeliverResult{Data: data}, err
} }
// FailHandler always returns an error // FailHandler always returns an error
@ -152,12 +152,12 @@ func (FailHandler) Name() string {
} }
// CheckTx always returns the given error // CheckTx always returns the given error
func (f FailHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (f FailHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
return res, errors.Wrap(f.Err) return res, errors.Wrap(f.Err)
} }
// DeliverTx always returns the given error // DeliverTx always returns the given error
func (f FailHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (f FailHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
return res, errors.Wrap(f.Err) return res, errors.Wrap(f.Err)
} }
@ -176,7 +176,7 @@ func (PanicHandler) Name() string {
} }
// CheckTx always panics // CheckTx always panics
func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
if p.Err != nil { if p.Err != nil {
panic(p.Err) panic(p.Err)
} }
@ -184,7 +184,7 @@ func (p PanicHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx bas
} }
// DeliverTx always panics // DeliverTx always panics
func (p PanicHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (p PanicHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
if p.Err != nil { if p.Err != nil {
panic(p.Err) panic(p.Err)
} }
@ -204,7 +204,7 @@ func (CheckHandler) Name() string {
} }
// CheckTx verifies the permissions // CheckTx verifies the permissions
func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.CheckResult, err error) {
check, ok := tx.Unwrap().(CheckTx) check, ok := tx.Unwrap().(CheckTx)
if !ok { if !ok {
return res, errors.ErrUnknownTxType(tx) return res, errors.ErrUnknownTxType(tx)
@ -219,7 +219,16 @@ func (c CheckHandler) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx bas
} }
// DeliverTx verifies the permissions // DeliverTx verifies the permissions
func (c CheckHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (c CheckHandler) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
// until something changes, just do the same as check check, ok := tx.Unwrap().(CheckTx)
return c.CheckTx(ctx, store, tx) if !ok {
return res, errors.ErrUnknownTxType(tx)
}
for _, perm := range check.Required {
if !ctx.HasPermission(perm) {
return res, errors.ErrUnauthorized()
}
}
return res, nil
} }

8
stack/helperware.go
View File

@ -25,14 +25,14 @@ func (_ CheckMiddleware) Name() string {
return NameCheck return NameCheck
} }
func (p CheckMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (p CheckMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
if !ctx.HasPermission(p.Required) { if !ctx.HasPermission(p.Required) {
return res, errors.ErrUnauthorized() return res, errors.ErrUnauthorized()
} }
return next.CheckTx(ctx, store, tx) return next.CheckTx(ctx, store, tx)
} }
func (p CheckMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (p CheckMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
if !ctx.HasPermission(p.Required) { if !ctx.HasPermission(p.Required) {
return res, errors.ErrUnauthorized() return res, errors.ErrUnauthorized()
} }
@ -51,12 +51,12 @@ func (_ GrantMiddleware) Name() string {
return NameGrant return NameGrant
} }
func (g GrantMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (g GrantMiddleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
ctx = ctx.WithPermissions(g.Auth) ctx = ctx.WithPermissions(g.Auth)
return next.CheckTx(ctx, store, tx) return next.CheckTx(ctx, store, tx)
} }
func (g GrantMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (g GrantMiddleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
ctx = ctx.WithPermissions(g.Auth) ctx = ctx.WithPermissions(g.Auth)
return next.DeliverTx(ctx, store, tx) return next.DeliverTx(ctx, store, tx)
} }

20
stack/interface.go
View File

@ -21,27 +21,27 @@ type Middleware interface {
type CheckerMiddle interface { type CheckerMiddle interface {
CheckTx(ctx basecoin.Context, store state.SimpleDB, CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error)
} }
type CheckerMiddleFunc func(basecoin.Context, state.SimpleDB, type CheckerMiddleFunc func(basecoin.Context, state.SimpleDB,
basecoin.Tx, basecoin.Checker) (basecoin.Result, error) basecoin.Tx, basecoin.Checker) (basecoin.CheckResult, error)
func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.SimpleDB, func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) { tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error) {
return c(ctx, store, tx, next) return c(ctx, store, tx, next)
} }
type DeliverMiddle interface { type DeliverMiddle interface {
DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx,
next basecoin.Deliver) (basecoin.Result, error) next basecoin.Deliver) (basecoin.DeliverResult, error)
} }
type DeliverMiddleFunc func(basecoin.Context, state.SimpleDB, type DeliverMiddleFunc func(basecoin.Context, state.SimpleDB,
basecoin.Tx, basecoin.Deliver) (basecoin.Result, error) basecoin.Tx, basecoin.Deliver) (basecoin.DeliverResult, error)
func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.SimpleDB, func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) { tx basecoin.Tx, next basecoin.Deliver) (basecoin.DeliverResult, error) {
return d(ctx, store, tx, next) return d(ctx, store, tx, next)
} }
@ -62,14 +62,14 @@ func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.SimpleDB,
type PassCheck struct{} type PassCheck struct{}
func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB, func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) { tx basecoin.Tx, next basecoin.Checker) (basecoin.CheckResult, error) {
return next.CheckTx(ctx, store, tx) return next.CheckTx(ctx, store, tx)
} }
type PassDeliver struct{} type PassDeliver struct{}
func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.SimpleDB, func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) { tx basecoin.Tx, next basecoin.Deliver) (basecoin.DeliverResult, error) {
return next.DeliverTx(ctx, store, tx) return next.DeliverTx(ctx, store, tx)
} }
@ -113,12 +113,12 @@ func (w wrapped) Name() string {
} }
func (w wrapped) CheckTx(ctx basecoin.Context, store state.SimpleDB, func (w wrapped) CheckTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) { tx basecoin.Tx, _ basecoin.Checker) (basecoin.CheckResult, error) {
return w.h.CheckTx(ctx, store, tx) return w.h.CheckTx(ctx, store, tx)
} }
func (w wrapped) DeliverTx(ctx basecoin.Context, store state.SimpleDB, func (w wrapped) DeliverTx(ctx basecoin.Context, store state.SimpleDB,
tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) { tx basecoin.Tx, _ basecoin.Deliver) (basecoin.DeliverResult, error) {
return w.h.DeliverTx(ctx, store, tx) return w.h.DeliverTx(ctx, store, tx)
} }

4
stack/middleware.go
View File

@ -31,7 +31,7 @@ func (m *middleware) wrapCtx(ctx basecoin.Context) basecoin.Context {
} }
// CheckTx always returns an empty success tx // CheckTx always returns an empty success tx
func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (basecoin.Result, error) { func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (basecoin.CheckResult, error) {
// make sure we pass in proper context to child // make sure we pass in proper context to child
next := secureCheck(m.next, ctx) next := secureCheck(m.next, ctx)
// set the permissions for this app // set the permissions for this app
@ -42,7 +42,7 @@ func (m *middleware) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx base
} }
// DeliverTx always returns an empty success tx // DeliverTx always returns an empty success tx
func (m *middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.Result, err error) { func (m *middleware) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx) (res basecoin.DeliverResult, err error) {
// make sure we pass in proper context to child // make sure we pass in proper context to child
next := secureDeliver(m.next, ctx) next := secureDeliver(m.next, ctx)
// set the permissions for this app // set the permissions for this app

4
stack/recovery.go
View File

@ -26,7 +26,7 @@ func (Recovery) Name() string {
var _ Middleware = Recovery{} var _ Middleware = Recovery{}
// CheckTx catches any panic and converts to error - fulfills Middlware interface // CheckTx catches any panic and converts to error - fulfills Middlware interface
func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.Result, err error) { func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Checker) (res basecoin.CheckResult, err error) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
err = normalizePanic(r) err = normalizePanic(r)
@ -36,7 +36,7 @@ func (Recovery) CheckTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.
} }
// DeliverTx catches any panic and converts to error - fulfills Middlware interface // DeliverTx catches any panic and converts to error - fulfills Middlware interface
func (Recovery) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.Result, err error) { func (Recovery) DeliverTx(ctx basecoin.Context, store state.SimpleDB, tx basecoin.Tx, next basecoin.Deliver) (res basecoin.DeliverResult, err error) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
err = normalizePanic(r) err = normalizePanic(r)