WIP, aminoification

Gopkg.toml

@@ -53,29 +53,28 @@
   version = "~1.2.1"
 
 [[constraint]]
-  version = "~0.10.2"
   name = "github.com/tendermint/abci"
+  version = "~0.10.2"
 
 [[constraint]]
-  version = "~0.5.0"
   name = "github.com/tendermint/go-crypto"
+  version = "0.6.1"
 
 [[constraint]]
-  version = "~0.7.3"
+  name = "github.com/tendermint/go-amino"
-  source = "github.com/tendermint/go-amino"
+  version = "0.9.6"
-  name = "github.com/tendermint/go-wire"
 
 [[constraint]]
-  version = "~0.7.0"
   name = "github.com/tendermint/iavl"
+  version = "~0.7.0"
 
 [[constraint]]
-  version = "~0.18.0-rc1"
   name = "github.com/tendermint/tendermint"
+  version = "~0.18.0-rc1"
 
 [[override]]
-  version = "~0.8.1"
   name = "github.com/tendermint/tmlibs"
+  version = "~0.8.1"
 
 [prune]
   go-tests = true

examples/basecoin/app/app.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 
 	abci "github.com/tendermint/abci/types"
-	oldwire "github.com/tendermint/go-wire"
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
@@ -84,37 +83,22 @@ func NewBasecoinApp(logger log.Logger, dbs map[string]dbm.DB) *BasecoinApp {
 }
 
 // custom tx codec
-// TODO: use new go-wire
 func MakeCodec() *wire.Codec {
-	const msgTypeSend = 0x1
+	var cdc = wire.NewCodec()
-	const msgTypeIssue = 0x2
-	const msgTypeQuiz = 0x3
-	const msgTypeSetTrend = 0x4
-	const msgTypeIBCTransferMsg = 0x5
-	const msgTypeIBCReceiveMsg = 0x6
-	const msgTypeBondMsg = 0x7
-	const msgTypeUnbondMsg = 0x8
-	var _ = oldwire.RegisterInterface(
-		struct{ sdk.Msg }{},
-		oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
-		oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
-		oldwire.ConcreteType{ibc.IBCTransferMsg{}, msgTypeIBCTransferMsg},
-		oldwire.ConcreteType{ibc.IBCReceiveMsg{}, msgTypeIBCReceiveMsg},
-		oldwire.ConcreteType{simplestake.BondMsg{}, msgTypeBondMsg},
-		oldwire.ConcreteType{simplestake.UnbondMsg{}, msgTypeUnbondMsg},
-	)
 
-	const accTypeApp = 0x1
+	// Register Msgs
-	var _ = oldwire.RegisterInterface(
+	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-		struct{ sdk.Account }{},
+	cdc.RegisterConcrete(bank.SendMsg{}, "basecoin/Send", nil)
-		oldwire.ConcreteType{&types.AppAccount{}, accTypeApp},
+	cdc.RegisterConcrete(bank.IssueMsg{}, "basecoin/Issue", nil)
-	)
+	cdc.RegisterConcrete(ibc.IBCTransferMsg{}, "basecoin/IBCTransferMsg", nil)
-	cdc := wire.NewCodec()
+	cdc.RegisterConcrete(ibc.IBCReceiveMsg{}, "basecoin/IBCReceiveMsg", nil)
+	cdc.RegisterConcrete(simplestake.BondMsg{}, "basecoin/BondMsg", nil)
+	cdc.RegisterConcrete(simplestake.UnbondMsg{}, "basecoin/UnbondMsg", nil)
+
+	// Register AppAccount
+	cdc.RegisterInterface((*sdk.Account)(nil), nil)
+	cdc.RegisterConcrete(&types.AppAccount{}, "basecoin/Account", nil)
 
-	// cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-	// bank.RegisterWire(cdc)   // Register bank.[SendMsg,IssueMsg] types.
-	// crypto.RegisterWire(cdc) // Register crypto.[PubKey,PrivKey,Signature] types.
-	// ibc.RegisterWire(cdc) // Register ibc.[IBCTransferMsg, IBCReceiveMsg] types.
 	return cdc
 }
 
@@ -127,7 +111,7 @@ func (app *BasecoinApp) txDecoder(txBytes []byte) (sdk.Tx, sdk.Error) {
 	}
 
 	// StdTx.Msg is an interface. The concrete types
-	// are registered by MakeTxCodec in bank.RegisterWire.
+	// are registered by MakeTxCodec in bank.RegisterAmino.
 	err := app.cdc.UnmarshalBinary(txBytes, &tx)
 	if err != nil {
 		return nil, sdk.ErrTxDecode("").TraceCause(err, "")

wire/wire.go

@@ -4,52 +4,13 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/tendermint/go-wire"
+	"github.com/tendermint/go-amino"
 )
 
-type Codec struct{}
+type Codec = amino.Codec
 
 func NewCodec() *Codec {
-	return &Codec{}
+	cdc := amino.NewCodec()
-}
+	RegisterAmino(cdc)
-
+	return cdc
-func (cdc *Codec) MarshalBinary(o interface{}) ([]byte, error) {
-	w, n, err := new(bytes.Buffer), new(int), new(error)
-	wire.WriteBinary(o, w, n, err)
-	return w.Bytes(), *err
-}
-
-func (cdc *Codec) UnmarshalBinary(bz []byte, o interface{}) error {
-	r, n, err := bytes.NewBuffer(bz), new(int), new(error)
-
-	rv := reflect.ValueOf(o)
-	if rv.Kind() == reflect.Ptr {
-		wire.ReadBinaryPtr(o, r, len(bz), n, err)
-	} else {
-		wire.ReadBinary(o, r, len(bz), n, err)
-	}
-	return *err
-}
-
-func (cdc *Codec) MarshalJSON(o interface{}) ([]byte, error) {
-	w, n, err := new(bytes.Buffer), new(int), new(error)
-	wire.WriteJSON(o, w, n, err)
-	return w.Bytes(), *err
-}
-
-func (cdc *Codec) UnmarshalJSON(bz []byte, o interface{}) (err error) {
-
-	rv := reflect.ValueOf(o)
-	if rv.Kind() == reflect.Ptr {
-		wire.ReadJSONPtr(o, bz, &err)
-	} else {
-		wire.ReadJSON(o, bz, &err)
-	}
-	return err
-}
-
-//----------------------------------------------
-
-func RegisterCrypto(cdc *Codec) {
-	// TODO
 }

x/stake/test_common.go

@@ -8,7 +8,6 @@ import (
 
 	abci "github.com/tendermint/abci/types"
 	crypto "github.com/tendermint/go-crypto"
-	oldwire "github.com/tendermint/go-wire"
 	dbm "github.com/tendermint/tmlibs/db"
 
 	"github.com/cosmos/cosmos-sdk/store"
@@ -84,36 +83,21 @@ func subspace(prefix []byte) (start, end []byte) {
 	return prefix, end
 }
 
-// custom tx codec
+func MakeCodec() *wire.Codec {
-// TODO: use new go-wire
+	var cdc = wire.NewCodec()
-func makeTestCodec() *wire.Codec {
 
-	const msgTypeSend = 0x1
+	// Register Msgs
-	const msgTypeIssue = 0x2
+	cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-	const msgTypeDeclareCandidacy = 0x3
+	cdc.RegisterConcrete(bank.SendMsg{}, "test/stake/Send", nil)
-	const msgTypeEditCandidacy = 0x4
+	cdc.RegisterConcrete(bank.IssueMsg{}, "test/stake/Issue", nil)
-	const msgTypeDelegate = 0x5
+	cdc.RegisterConcrete(MsgDeclareCandidacy{}, "test/stake/DeclareCandidacy", nil)
-	const msgTypeUnbond = 0x6
+	cdc.RegisterConcrete(MsgEditCandidacy{}, "test/stake/EditCandidacy", nil)
-	var _ = oldwire.RegisterInterface(
+	cdc.RegisterConcrete(MsgUnbond{}, "test/stake/Unbond", nil)
-		struct{ sdk.Msg }{},
-		oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend},
-		oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue},
-		oldwire.ConcreteType{MsgDeclareCandidacy{}, msgTypeDeclareCandidacy},
-		oldwire.ConcreteType{MsgEditCandidacy{}, msgTypeEditCandidacy},
-		oldwire.ConcreteType{MsgDelegate{}, msgTypeDelegate},
-		oldwire.ConcreteType{MsgUnbond{}, msgTypeUnbond},
-	)
 
-	const accTypeApp = 0x1
+	// Register AppAccount
-	var _ = oldwire.RegisterInterface(
+	cdc.RegisterInterface((*sdk.Account)(nil), nil)
-		struct{ sdk.Account }{},
+	cdc.RegisterConcrete(&auth.BaseAccount{}, "test/stake/Account", nil)
-		oldwire.ConcreteType{&auth.BaseAccount{}, accTypeApp},
-	)
-	cdc := wire.NewCodec()
 
-	// cdc.RegisterInterface((*sdk.Msg)(nil), nil)
-	// bank.RegisterWire(cdc)   // Register bank.[SendMsg,IssueMsg] types.
-	// crypto.RegisterWire(cdc) // Register crypto.[PubKey,PrivKey,Signature] types.
 	return cdc
 }