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

NewXYZTx returns Tx already wrapped, except for sigs

This commit is contained in:
Ethan Frey 2017-07-03 15:01:28 +02:00
parent 995452ea02
commit 225904b010
8 changed files with 75 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
modules/coin/tx.go
View File

@ -102,7 +102,11 @@ type SendTx struct {
Outputs []TxOutput `json:"outputs"`
}
var _ basecoin.Tx = SendTx{}.Wrap()
var _ basecoin.Tx = NewSendTx(nil, nil)
func NewSendTx(in []TxInput, out []TxOutput) basecoin.Tx {
return SendTx{Inputs: in, Outputs: out}.Wrap()
}
func (tx SendTx) ValidateBasic() error {
// this just makes sure all the inputs and outputs are properly formatted,

104
modules/coin/tx_test.go
View File

@ -106,61 +106,63 @@ func TestTxValidateTx(t *testing.T) {
// totals don't match
cases := []struct {
valid bool
tx SendTx
tx basecoin.Tx
}{
// 0-2. valid cases
{true, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2)},
Outputs: []TxOutput{NewTxOutput(addr2, someCoins)},
}},
{true, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, otherCoins, 5)},
Outputs: []TxOutput{NewTxOutput(addr3, bothCoins)},
}},
{true, SendTx{
Inputs: []TxInput{NewTxInput(addr1, bothCoins, 42)},
Outputs: []TxOutput{NewTxOutput(addr2, someCoins), NewTxOutput(addr3, otherCoins)},
}},
{true, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2)},
[]TxOutput{NewTxOutput(addr2, someCoins)},
)},
{true, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, otherCoins, 5)},
[]TxOutput{NewTxOutput(addr3, bothCoins)},
)},
{true, NewSendTx(
[]TxInput{NewTxInput(addr1, bothCoins, 42)},
[]TxOutput{NewTxOutput(addr2, someCoins), NewTxOutput(addr3, otherCoins)},
)},
// 3-4. missing cases
{false, SendTx{
Outputs: []TxOutput{NewTxOutput(addr2, someCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2)},
}},
{false, NewSendTx(
nil,
[]TxOutput{NewTxOutput(addr2, someCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2)},
nil,
)},
// 5-8. invalid inputs
{false, SendTx{
Inputs: []TxInput{NewTxInput(noAddr, someCoins, 2)},
Outputs: []TxOutput{NewTxOutput(addr2, someCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, -1)},
Outputs: []TxOutput{NewTxOutput(addr2, someCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, noCoins, 2)},
Outputs: []TxOutput{NewTxOutput(addr2, noCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, minusCoins, 2)},
Outputs: []TxOutput{NewTxOutput(addr2, minusCoins)},
}},
{false, NewSendTx(
[]TxInput{NewTxInput(noAddr, someCoins, 2)},
[]TxOutput{NewTxOutput(addr2, someCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, -1)},
[]TxOutput{NewTxOutput(addr2, someCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, noCoins, 2)},
[]TxOutput{NewTxOutput(addr2, noCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, minusCoins, 2)},
[]TxOutput{NewTxOutput(addr2, minusCoins)},
)},
// 9-11. totals don't match
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 7)},
Outputs: []TxOutput{NewTxOutput(addr2, moreCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, minusCoins, 5)},
Outputs: []TxOutput{NewTxOutput(addr3, someCoins)},
}},
{false, SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, moreCoins, 5)},
Outputs: []TxOutput{NewTxOutput(addr3, bothCoins)},
}},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 7)},
[]TxOutput{NewTxOutput(addr2, moreCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, minusCoins, 5)},
[]TxOutput{NewTxOutput(addr3, someCoins)},
)},
{false, NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2), NewTxInput(addr2, moreCoins, 5)},
[]TxOutput{NewTxOutput(addr3, bothCoins)},
)},
}
for i, tc := range cases {
@ -181,10 +183,10 @@ func TestTxSerializeTx(t *testing.T) {
addr2 := basecoin.Actor{App: "coin", Address: []byte{3, 4}}
someCoins := types.Coins{{"atom", 123}}
send := SendTx{
Inputs: []TxInput{NewTxInput(addr1, someCoins, 2)},
Outputs: []TxOutput{NewTxOutput(addr2, someCoins)},
}.Wrap()
send := NewSendTx(
[]TxInput{NewTxInput(addr1, someCoins, 2)},
[]TxOutput{NewTxOutput(addr2, someCoins)},
)
js, err := data.ToJSON(send)
require.Nil(err)

4
modules/fee/tx.go
View File

@ -25,8 +25,8 @@ type Fee struct {
// Gas types.Coin `json:"gas"` // ?????
}
func NewFee(tx basecoin.Tx, fee types.Coin, payer basecoin.Actor) *Fee {
return &Fee{Tx: tx, Fee: fee, Payer: payer}
func NewFee(tx basecoin.Tx, fee types.Coin, payer basecoin.Actor) basecoin.Tx {
return (&Fee{Tx: tx, Fee: fee, Payer: payer}).Wrap()
}
func (f *Fee) ValidateBasic() error {

6
stack/chain_test.go
View File

@ -18,14 +18,14 @@ func TestChain(t *testing.T) {
msg := "got it"
chainID := "my-chain"
raw := txs.NewRaw([]byte{1, 2, 3, 4}).Wrap()
raw := txs.NewRaw([]byte{1, 2, 3, 4})
cases := []struct {
tx basecoin.Tx
valid bool
errorMsg string
}{
{txs.NewChain(chainID, raw).Wrap(), true, ""},
{txs.NewChain("someone-else", raw).Wrap(), false, "someone-else"},
{txs.NewChain(chainID, raw), true, ""},
{txs.NewChain("someone-else", raw), false, "someone-else"},
{raw, false, "No chain id provided"},
}

2
stack/middleware_test.go
View File

@ -19,7 +19,7 @@ func TestPermissionSandbox(t *testing.T) {
// generic args
ctx := NewContext(log.NewNopLogger())
store := types.NewMemKVStore()
raw := txs.NewRaw([]byte{1, 2, 3, 4}).Wrap()
raw := txs.NewRaw([]byte{1, 2, 3, 4})
rawBytes, err := data.ToWire(raw)
require.Nil(err)

2
stack/signature_test.go
View File

@ -19,7 +19,7 @@ func TestSignatureChecks(t *testing.T) {
// generic args
ctx := NewContext(log.NewNopLogger())
store := types.NewMemKVStore()
raw := txs.NewRaw([]byte{1, 2, 3, 4}).Wrap()
raw := txs.NewRaw([]byte{1, 2, 3, 4})
// let's make some keys....
priv1 := crypto.GenPrivKeyEd25519().Wrap()

12
txs/base.go
View File

@ -55,8 +55,8 @@ func (r Raw) ValidateBasic() error {
return nil
}
func NewRaw(d []byte) Raw {
return Raw{data.Bytes(d)}
func NewRaw(d []byte) basecoin.Tx {
return Raw{data.Bytes(d)}.Wrap()
}
/**** MultiTx ******/
@ -64,8 +64,8 @@ type MultiTx struct {
Txs []basecoin.Tx `json:"txs"`
}
func NewMultiTx(txs ...basecoin.Tx) *MultiTx {
return &MultiTx{Txs: txs}
func NewMultiTx(txs ...basecoin.Tx) basecoin.Tx {
return (&MultiTx{Txs: txs}).Wrap()
}
func (mt *MultiTx) Wrap() basecoin.Tx {
@ -90,8 +90,8 @@ type Chain struct {
ChainID string `json:"chain_id"`
}
func NewChain(chainID string, tx basecoin.Tx) *Chain {
return &Chain{Tx: tx, ChainID: chainID}
func NewChain(chainID string, tx basecoin.Tx) basecoin.Tx {
return (&Chain{Tx: tx, ChainID: chainID}).Wrap()
}
func (c *Chain) Wrap() basecoin.Tx {

8
txs/base_test.go
View File

@ -16,15 +16,15 @@ func TestEncoding(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
raw := NewRaw([]byte{0x34, 0xa7}).Wrap()
raw2 := NewRaw([]byte{0x73, 0x86, 0x22}).Wrap()
raw := NewRaw([]byte{0x34, 0xa7})
raw2 := NewRaw([]byte{0x73, 0x86, 0x22})
cases := []struct {
Tx basecoin.Tx
}{
{raw},
{NewMultiTx(raw, raw2).Wrap()},
{NewChain("foobar", raw).Wrap()},
{NewMultiTx(raw, raw2)},
{NewChain("foobar", raw)},
}
for idx, tc := range cases {