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

Merge pull request #161 from tendermint/unstable-cleanup 

Unstable cleanup
This commit is contained in:
Ethan Frey 2017-07-08 21:08:32 +02:00 committed by GitHub
parent 58bc1e3cf8 1821f8bd7a
commit ad94d060d8
17 changed files with 105 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/app.go
View File

@ -34,6 +34,8 @@ type Basecoin struct {
logger log.Logger
}
var _ abci.Application = &Basecoin{}
// NewBasecoin - create a new instance of the basecoin application
func NewBasecoin(handler basecoin.Handler, eyesCli *eyes.Client, logger log.Logger) *Basecoin {
state := sm.NewState(eyesCli, logger.With("module", "state"))

23
cmd/basecoin/commands/utils.go
View File

@ -1,23 +0,0 @@
package commands
import "encoding/hex"
// Returns true for non-empty hex-string prefixed with "0x"
func isHex(s string) bool {
if len(s) > 2 && s[:2] == "0x" {
_, err := hex.DecodeString(s[2:])
if err != nil {
return false
}
return true
}
return false
}
// StripHex remove the first two hex bytes
func StripHex(s string) string {
if isHex(s) {
return s[2:]
}
return s
}

24
cmd/basecoin/commands/utils_test.go
View File

@ -1,24 +0,0 @@
package commands
import (
"encoding/hex"
"testing"
"github.com/stretchr/testify/assert"
)
func TestHex(t *testing.T) {
assert := assert.New(t)
//test isHex
hexNoPrefix := hex.EncodeToString([]byte("foobar"))
hexWPrefix := "0x" + hexNoPrefix
str := "foobar"
strWPrefix := "0xfoobar"
assert.True(isHex(hexWPrefix), "isHex not identifying hex with 0x prefix")
assert.False(isHex(hexNoPrefix), "isHex shouldn't identify hex without 0x prefix")
assert.False(isHex(str), "isHex shouldn't identify non-hex string")
assert.False(isHex(strWPrefix), "isHex shouldn't identify non-hex string with 0x prefix")
assert.True(StripHex(hexWPrefix) == hexNoPrefix, "StripHex doesn't remove first two characters")
}

8
errors/common_test.go
View File

@ -19,15 +19,15 @@ func (h holder) Unwrap() validate {
return h.validate
}
type DemoTx struct {
type demoTx struct {
Age int
}
func (t DemoTx) Wrap() holder {
func (t demoTx) Wrap() holder {
return holder{t}
}
func (t DemoTx) ValidateBasic() error {
func (t demoTx) ValidateBasic() error {
return nil
}
@ -45,7 +45,7 @@ func TestErrorMatches(t *testing.T) {
{errWrongChain, ErrWrongChain("hakz"), true},
{errUnknownTxType, ErrUnknownTxType(holder{}), true},
{errUnknownTxType, ErrUnknownTxType("some text here..."), true},
{errUnknownTxType, ErrUnknownTxType(DemoTx{5}.Wrap()), true},
{errUnknownTxType, ErrUnknownTxType(demoTx{5}.Wrap()), true},
}
for i, tc := range cases {

9
modules/auth/tx.go
View File

@ -1,5 +1,5 @@
/*
package auth contains generic Signable implementations that can be used
Package auth contains generic Signable implementations that can be used
by your application or tests to handle authentication needs.
It currently supports transaction data as opaque bytes and either single
@ -71,14 +71,13 @@ func NewSig(tx basecoin.Tx) *OneSig {
return &OneSig{Tx: tx}
}
//nolint
func (s *OneSig) Wrap() basecoin.Tx {
return basecoin.Tx{s}
}
func (s *OneSig) Next() basecoin.Tx {
return s.Tx
}
func (s *OneSig) ValidateBasic() error {
return s.Tx.ValidateBasic()
}
@ -143,14 +142,13 @@ func NewMulti(tx basecoin.Tx) *MultiSig {
return &MultiSig{Tx: tx}
}
// nolint
func (s *MultiSig) Wrap() basecoin.Tx {
return basecoin.Tx{s}
}
func (s *MultiSig) Next() basecoin.Tx {
return s.Tx
}
func (s *MultiSig) ValidateBasic() error {
return s.Tx.ValidateBasic()
}
@ -204,6 +202,7 @@ func (s *MultiSig) Signers() ([]crypto.PubKey, error) {
return keys, nil
}
// Sign - sign the transaction with private key
func Sign(tx keys.Signable, key crypto.PrivKey) error {
msg := tx.SignBytes()
pubkey := key.PubKey()

12
modules/base/tx.go
View File

@ -22,18 +22,21 @@ func init() {
}
/**** MultiTx ******/
// MultiTx - a transaction containing multiple transactions
type MultiTx struct {
Txs []basecoin.Tx `json:"txs"`
}
var _ basecoin.TxInner = &MultiTx{}
//nolint - TxInner Functions
func NewMultiTx(txs ...basecoin.Tx) basecoin.Tx {
return (MultiTx{Txs: txs}).Wrap()
}
func (mt MultiTx) Wrap() basecoin.Tx {
return basecoin.Tx{mt}
}
func (mt MultiTx) ValidateBasic() error {
for _, t := range mt.Txs {
err := t.ValidateBasic()
@ -52,14 +55,15 @@ type ChainTx struct {
ChainID string `json:"chain_id"`
}
var _ basecoin.TxInner = &ChainTx{}
//nolint - TxInner Functions
func NewChainTx(chainID string, tx basecoin.Tx) basecoin.Tx {
return (ChainTx{Tx: tx, ChainID: chainID}).Wrap()
}
func (c ChainTx) Wrap() basecoin.Tx {
return basecoin.Tx{c}
}
func (c ChainTx) ValidateBasic() error {
// TODO: more checks? chainID?
return c.Tx.ValidateBasic()

26
modules/coin/coin.go
View File

@ -118,10 +118,10 @@ func (coins Coins) IsValid() bool {
//
// TODO: handle empty coins!
// Currently appends an empty coin ...
func (coinsA Coins) Plus(coinsB Coins) Coins {
func (coins Coins) Plus(coinsB Coins) Coins {
sum := []Coin{}
indexA, indexB := 0, 0
lenA, lenB := len(coinsA), len(coinsB)
lenA, lenB := len(coins), len(coinsB)
for {
if indexA == lenA {
if indexB == lenB {
@ -129,9 +129,9 @@ func (coinsA Coins) Plus(coinsB Coins) Coins {
}
return append(sum, coinsB[indexB:]...)
} else if indexB == lenB {
return append(sum, coinsA[indexA:]...)
return append(sum, coins[indexA:]...)
}
coinA, coinB := coinsA[indexA], coinsB[indexB]
coinA, coinB := coins[indexA], coinsB[indexB]
switch strings.Compare(coinA.Denom, coinB.Denom) {
case -1:
sum = append(sum, coinA)
@ -168,15 +168,15 @@ func (coins Coins) Negative() Coins {
}
// Minus subtracts a set of coins from another (adds the inverse)
func (coinsA Coins) Minus(coinsB Coins) Coins {
return coinsA.Plus(coinsB.Negative())
func (coins Coins) Minus(coinsB Coins) Coins {
return coins.Plus(coinsB.Negative())
}
// IsGTE returns True iff coinsA is NonNegative(), and for every
// IsGTE returns True iff coins is NonNegative(), and for every
// currency in coinsB, the currency is present at an equal or greater
// amount in coinsB
func (coinsA Coins) IsGTE(coinsB Coins) bool {
diff := coinsA.Minus(coinsB)
func (coins Coins) IsGTE(coinsB Coins) bool {
diff := coins.Minus(coinsB)
if len(diff) == 0 {
return true
}
@ -189,12 +189,12 @@ func (coins Coins) IsZero() bool {
}
// IsEqual returns true if the two sets of Coins have the same value
func (coinsA Coins) IsEqual(coinsB Coins) bool {
if len(coinsA) != len(coinsB) {
func (coins Coins) IsEqual(coinsB Coins) bool {
if len(coins) != len(coinsB) {
return false
}
for i := 0; i < len(coinsA); i++ {
if coinsA[i] != coinsB[i] {
for i := 0; i < len(coins); i++ {
if coins[i] != coinsB[i] {
return false
}
}

6
modules/fee/tx.go
View File

@ -18,6 +18,8 @@ func init() {
/**** Fee ****/
var _ basecoin.TxLayer = &Fee{}
// Fee attaches a fee payment to the embedded tx
type Fee struct {
Tx basecoin.Tx `json:"tx"`
@ -26,19 +28,17 @@ type Fee struct {
// Gas coin.Coin `json:"gas"` // ?????
}
// nolint - TxInner Functions
func NewFee(tx basecoin.Tx, fee coin.Coin, payer basecoin.Actor) basecoin.Tx {
return (&Fee{Tx: tx, Fee: fee, Payer: payer}).Wrap()
}
func (f *Fee) ValidateBasic() error {
// TODO: more checks
return f.Tx.ValidateBasic()
}
func (f *Fee) Wrap() basecoin.Tx {
return basecoin.Tx{f}
}
func (f *Fee) Next() basecoin.Tx {
return f.Tx
}

6
publish/dist.sh
View File

@ -5,7 +5,7 @@ REPO_NAME="basecoin"
# Get the version from the environment, or try to figure it out.
if [ -z $VERSION ]; then
VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
fi
if [ -z "$VERSION" ]; then
echo "Please specify a version."
@ -34,8 +34,8 @@ docker run --rm -e "BUILD_TAGS=$BUILD_TAGS" -v "$(pwd)":/go/src/github.com/tende
rm -rf ./build/dist
mkdir -p ./build/dist
for FILENAME in $(find ./build/pkg -mindepth 1 -maxdepth 1 -type f); do
FILENAME=$(basename "$FILENAME")
cp "./build/pkg/${FILENAME}" "./build/dist/${REPO_NAME}_${VERSION}_${FILENAME}"
FILENAME=$(basename "$FILENAME")
cp "./build/pkg/${FILENAME}" "./build/dist/${REPO_NAME}_${VERSION}_${FILENAME}"
done
# Make the checksums.

24
publish/dist_build.sh
View File

@ -27,13 +27,13 @@ make get_vendor_deps
# Build!
echo "==> Building basecoin..."
"$(which gox)" \
-os="${XC_OS}" \
-arch="${XC_ARCH}" \
-osarch="!darwin/arm !solaris/amd64 !freebsd/amd64" \
-ldflags "-X ${GIT_IMPORT}.GitCommit='${GIT_COMMIT}' -X ${GIT_IMPORT}.GitDescribe='${GIT_DESCRIBE}'" \
-output "build/pkg/{{.OS}}_{{.Arch}}/basecoin" \
-tags="${BUILD_TAGS}" \
github.com/tendermint/basecoin/cmd/basecoin
-os="${XC_OS}" \
-arch="${XC_ARCH}" \
-osarch="!darwin/arm !solaris/amd64 !freebsd/amd64" \
-ldflags "-X ${GIT_IMPORT}.GitCommit='${GIT_COMMIT}' -X ${GIT_IMPORT}.GitDescribe='${GIT_DESCRIBE}'" \
-output "build/pkg/{{.OS}}_{{.Arch}}/basecoin" \
-tags="${BUILD_TAGS}" \
github.com/tendermint/basecoin/cmd/basecoin
echo "==> Building basecli..."
"$(which gox)" \
@ -48,12 +48,12 @@ echo "==> Building basecli..."
# Zip all the files.
echo "==> Packaging..."
for PLATFORM in $(find ./build/pkg -mindepth 1 -maxdepth 1 -type d); do
OSARCH=$(basename "${PLATFORM}")
echo "--> ${OSARCH}"
OSARCH=$(basename "${PLATFORM}")
echo "--> ${OSARCH}"
pushd "$PLATFORM" >/dev/null 2>&1
zip "../${OSARCH}.zip" ./*
popd >/dev/null 2>&1
pushd "$PLATFORM" >/dev/null 2>&1
zip "../${OSARCH}.zip" ./*
popd >/dev/null 2>&1
done

1
publish/print_test_account.go
View File

@ -4,6 +4,7 @@ package main
import (
"fmt"
"github.com/tendermint/basecoin/tests"
"github.com/tendermint/go-wire"
)

6
publish/print_txs.go
View File

@ -9,11 +9,11 @@ import (
"time"
"github.com/gorilla/websocket"
cmn "github.com/tendermint/tmlibs/common"
"github.com/tendermint/tendermint/rpc/lib/client"
"github.com/tendermint/tendermint/rpc/lib/types"
"github.com/tendermint/go-wire"
_ "github.com/tendermint/tendermint/rpc/core/types" // Register RPCResponse > Result types
"github.com/tendermint/tendermint/rpc/lib/client"
"github.com/tendermint/tendermint/rpc/lib/types"
cmn "github.com/tendermint/tmlibs/common"
)
func main() {

2
publish/publish.sh
View File

@ -2,6 +2,6 @@
# Get the version from the environment, or try to figure it out.
if [ -z $VERSION ]; then
VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
VERSION=$(awk -F\" '/Version =/ { print $2; exit }' < version/version.go)
fi
aws s3 cp --recursive build/dist s3://tendermint/binaries/basecoin/v${VERSION} --acl public-read

1
stack/context.go
View File

@ -23,6 +23,7 @@ type secureContext struct {
log.Logger
}
// NewContext - create a new secureContext
func NewContext(chain string, logger log.Logger) basecoin.Context {
return secureContext{
id: nonce(rand.Int63()),

27
stack/helpers.go
View File

@ -33,10 +33,15 @@ type RawTx struct {
data.Bytes
}
var _ basecoin.TxInner = RawTx{}
// nolint
func NewRawTx(d []byte) basecoin.Tx {
return RawTx{data.Bytes(d)}.Wrap()
}
func (r RawTx) Wrap() basecoin.Tx {
return basecoin.Tx{r}
}
func (r RawTx) ValidateBasic() error {
if len(r.Bytes) > rawMaxSize {
return errors.ErrTooLarge()
@ -44,10 +49,6 @@ func (r RawTx) ValidateBasic() error {
return nil
}
func NewRawTx(d []byte) basecoin.Tx {
return RawTx{data.Bytes(d)}.Wrap()
}
// OKHandler just used to return okay to everything
type OKHandler struct {
Log string
@ -56,7 +57,8 @@ type OKHandler struct {
var _ basecoin.Handler = OKHandler{}
func (_ OKHandler) Name() string {
// Name - return handler's name
func (OKHandler) Name() string {
return NameOK
}
@ -77,18 +79,19 @@ type EchoHandler struct {
var _ basecoin.Handler = EchoHandler{}
func (_ EchoHandler) Name() string {
// Name - return handler's name
func (EchoHandler) Name() string {
return NameEcho
}
// CheckTx always returns an empty success tx
func (_ EchoHandler) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
func (EchoHandler) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
data, err := data.ToWire(tx)
return basecoin.Result{Data: data}, err
}
// DeliverTx always returns an empty success tx
func (_ EchoHandler) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
func (EchoHandler) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx) (res basecoin.Result, err error) {
data, err := data.ToWire(tx)
return basecoin.Result{Data: data}, err
}
@ -101,7 +104,8 @@ type FailHandler struct {
var _ basecoin.Handler = FailHandler{}
func (_ FailHandler) Name() string {
// Name - return handler's name
func (FailHandler) Name() string {
return NameFail
}
@ -124,7 +128,8 @@ type PanicHandler struct {
var _ basecoin.Handler = PanicHandler{}
func (_ PanicHandler) Name() string {
// Name - return handler's name
func (PanicHandler) Name() string {
return NamePanic
}

1
stack/helperware.go
View File

@ -1,3 +1,4 @@
//nolint
package stack
import (

49
stack/interface.go
View File

@ -1,3 +1,4 @@
//nolint
package stack
import (
@ -19,57 +20,70 @@ type Middleware interface {
}
type CheckerMiddle interface {
CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error)
CheckTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error)
}
type CheckerMiddleFunc func(basecoin.Context, state.KVStore, basecoin.Tx, basecoin.Checker) (basecoin.Result, error)
type CheckerMiddleFunc func(basecoin.Context, state.KVStore,
basecoin.Tx, basecoin.Checker) (basecoin.Result, error)
func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
func (c CheckerMiddleFunc) CheckTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
return c(ctx, store, tx, next)
}
type DeliverMiddle interface {
DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error)
DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx,
next basecoin.Deliver) (basecoin.Result, error)
}
type DeliverMiddleFunc func(basecoin.Context, state.KVStore, basecoin.Tx, basecoin.Deliver) (basecoin.Result, error)
type DeliverMiddleFunc func(basecoin.Context, state.KVStore,
basecoin.Tx, basecoin.Deliver) (basecoin.Result, error)
func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
func (d DeliverMiddleFunc) DeliverTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
return d(ctx, store, tx, next)
}
type SetOptionMiddle interface {
SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error)
SetOption(l log.Logger, store state.KVStore, module,
key, value string, next basecoin.SetOptioner) (string, error)
}
type SetOptionMiddleFunc func(log.Logger, state.KVStore, string, string, string, basecoin.SetOptioner) (string, error)
type SetOptionMiddleFunc func(log.Logger, state.KVStore,
string, string, string, basecoin.SetOptioner) (string, error)
func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
func (c SetOptionMiddleFunc) SetOption(l log.Logger, store state.KVStore,
module, key, value string, next basecoin.SetOptioner) (string, error) {
return c(l, store, module, key, value, next)
}
// holders
type PassCheck struct{}
func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
func (_ PassCheck) CheckTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, next basecoin.Checker) (basecoin.Result, error) {
return next.CheckTx(ctx, store, tx)
}
type PassDeliver struct{}
func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
func (_ PassDeliver) DeliverTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, next basecoin.Deliver) (basecoin.Result, error) {
return next.DeliverTx(ctx, store, tx)
}
type PassOption struct{}
func (_ PassOption) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
func (_ PassOption) SetOption(l log.Logger, store state.KVStore, module,
key, value string, next basecoin.SetOptioner) (string, error) {
return next.SetOption(l, store, module, key, value)
}
type NopOption struct{}
func (_ NopOption) SetOption(l log.Logger, store state.KVStore, module, key, value string, next basecoin.SetOptioner) (string, error) {
func (_ NopOption) SetOption(l log.Logger, store state.KVStore, module,
key, value string, next basecoin.SetOptioner) (string, error) {
return "", nil
}
@ -98,14 +112,17 @@ func (w wrapped) Name() string {
return w.h.Name()
}
func (w wrapped) CheckTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) {
func (w wrapped) CheckTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, _ basecoin.Checker) (basecoin.Result, error) {
return w.h.CheckTx(ctx, store, tx)
}
func (w wrapped) DeliverTx(ctx basecoin.Context, store state.KVStore, tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) {
func (w wrapped) DeliverTx(ctx basecoin.Context, store state.KVStore,
tx basecoin.Tx, _ basecoin.Deliver) (basecoin.Result, error) {
return w.h.DeliverTx(ctx, store, tx)
}
func (w wrapped) SetOption(l log.Logger, store state.KVStore, module, key, value string, _ basecoin.SetOptioner) (string, error) {
func (w wrapped) SetOption(l log.Logger, store state.KVStore,
module, key, value string, _ basecoin.SetOptioner) (string, error) {
return w.h.SetOption(l, store, module, key, value)
}