R4R: Colin/store

client/plasmacli/eth/balance.go

@@ -15,8 +15,8 @@ func init() {
 
 var balanceCmd = &cobra.Command{
 	Use:   "balance <account>",
-	Short: "Query for balance avaliable for withdraw from rootchain",
-	Long: `Query for balance avaliable for withdrawal from rootchain.
+	Short: "Query for balance available for withdraw from rootchain",
+	Long: `Query for balance available for withdrawal from rootchain.
 
 Usage: 
 	plasmacli eth query balance <account>

client/plasmacli/eth/challenge.go

@@ -79,7 +79,7 @@ Usage:
 			var result *tm.ResultTx
 			result, confirmSignatures, err = getProof(owner, challengingPos)
 			if err != nil {
-				fmt.Errorf("failed to retrieve exit information: { %s }", err)
+				return fmt.Errorf("failed to retrieve exit information: { %s }", err)
 			}
 
 			txBytes = result.Tx

client/plasmacli/eth/getDeposits.go

@@ -16,8 +16,8 @@ func init() {
 
 var getDepositsCmd = &cobra.Command{
 	Use:   "deposit <nonce>",
-	Short: "Query for a deposit that occured on the rootchain",
-	Long: `Queries for deposits that occured on the rootchain.
+	Short: "Query for a deposit that occurred on the rootchain",
+	Long: `Queries for deposits that occurred on the rootchain.
 
 Usage:
 	plasmacli eth query deposit <nonce>

client/plasmacli/eth/getExits.go

@@ -97,7 +97,7 @@ Usage:
 		}
 
 		if err := displayExits(curr, lim, addr, viper.GetBool(depositsF)); err != nil {
-			return fmt.Errorf("failure occured while querying exits: { %s }", err)
+			return fmt.Errorf("failure occurred while querying exits: { %s }", err)
 		}
 
 		return nil

client/plasmacli/eth/prove.go

@@ -4,10 +4,10 @@ import (
 	"fmt"
 	ks "github.com/FourthState/plasma-mvp-sidechain/client/store"
 	"github.com/FourthState/plasma-mvp-sidechain/plasma"
-	"github.com/FourthState/plasma-mvp-sidechain/store"
-	"github.com/cosmos/cosmos-sdk/client/context"
+	//	"github.com/FourthState/plasma-mvp-sidechain/store"
+	//	"github.com/cosmos/cosmos-sdk/client/context"
 	ethcmn "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/rlp"
+	//	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/spf13/cobra"
 	tm "github.com/tendermint/tendermint/rpc/core/types"
 )
@@ -73,30 +73,32 @@ var proveCmd = &cobra.Command{
 
 // Returns transaction results for given position
 // Trusts connected full node
+
+//TODO: REDO
 func getProof(addr ethcmn.Address, position plasma.Position) (*tm.ResultTx, []byte, error) {
-	ctx := context.NewCLIContext().WithTrustNode(true)
-
-	// query for the output
-	key := append(addr.Bytes(), position.Bytes()...)
-	res, err := ctx.QueryStore(key, "utxo")
-	if err != nil {
-		return &tm.ResultTx{}, nil, err
-	}
-
-	utxo := store.UTXO{}
-	if err := rlp.DecodeBytes(res, &utxo); err != nil {
-		return &tm.ResultTx{}, nil, err
-	}
-
-	// query tm node for information about this tx
-	result, err := ctx.Client.Tx(utxo.MerkleHash, true)
-	if err != nil {
-		return &tm.ResultTx{}, nil, err
-	}
-
-	// Look for confirmation signatures
-	key = append([]byte("confirmSignature"), utxo.Position.Bytes()...)
-	sigs, err := ctx.QueryStore(key, "plasma")
-
-	return result, sigs, nil
+	/*	ctx := context.NewCLIContext().WithTrustNode(true)
+
+		// query for the output
+		key := append(store.Key, position.Bytes()...)
+		res, err := ctx.QueryStore(key, "outputs")
+		if err != nil {
+			return &tm.ResultTx{}, nil, err
+		}
+
+		utxo := store.Output{}
+		if err := rlp.DecodeBytes(res, &utxo); err != nil {
+			return &tm.ResultTx{}, nil, err
+		}
+
+		// query tm node for information about this tx
+		result, err := ctx.Client.Tx(utxo.MerkleHash, true)
+		if err != nil {
+			return &tm.ResultTx{}, nil, err
+		}
+
+		// Look for confirmation signatures
+		key = append([]byte("confirmSignature"), utxo.Position.Bytes()...)
+		sigs, err := ctx.QueryStore(key, "plasma")
+	*/
+	return &tm.ResultTx{}, []byte{}, nil
 }

client/plasmacli/eth/rootchain.go

@@ -13,7 +13,7 @@ var rootchainCmd = &cobra.Command{
 	Use:   "rootchain",
 	Short: "Display rootchain contract information",
 	Long: `Display last committed block, total contract balance, total withdraw balance, minimum exit bond, and operator address.
-Total contract balance does not include total withdraw balance. The total withdraw balance are exits that have been finalized, but not transfered yet.`,
+Total contract balance does not include total withdraw balance. The total withdraw balance are exits that have been finalized, but not transferred yet.`,
 	Args: cobra.ExactArgs(0),
 	RunE: func(cmd *cobra.Command, agrs []string) error {
 		lastCommittedBlock, err := rc.contract.LastCommittedBlock(nil)

client/plasmacli/eth/withdraw.go

@@ -16,8 +16,8 @@ func init() {
 
 var withdrawCmd = &cobra.Command{
 	Use:   "withdraw <account>",
-	Short: "Withdraw all avaliable funds from rootchain contract",
-	Long: `Withdraw all avaliable funds from the rootchain contract
+	Short: "Withdraw all available funds from rootchain contract",
+	Long: `Withdraw all available funds from the rootchain contract
 
 Usage:
 	plasmacli eth withdraw <account> --gas-limit 30000`,

client/plasmacli/main.go

@@ -44,22 +44,19 @@ func init() {
 func main() {
 	cobra.EnableCommandSorting = false
 
-	rootCmd.Flags().String(client.FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
+	rootCmd.PersistentFlags().String(client.FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
+	rootCmd.PersistentFlags().Bool(client.FlagTrustNode, true, "Trust connected full node (don't verify proofs for responses)")
 	rootCmd.PersistentFlags().StringP(store.DirFlag, "d", homeDir, "directory for plasmacli")
-	if err := viper.BindPFlags(rootCmd.PersistentFlags()); err != nil {
-		fmt.Println(err)
-	}
 
-	if err := viper.BindPFlags(rootCmd.Flags()); err != nil {
+	viper.Set(client.FlagListenAddr, "tcp://localhost:1317")
+
+	if err := viper.BindPFlags(rootCmd.PersistentFlags()); err != nil {
 		fmt.Println(err)
 	}
 
-	viper.Set(client.FlagListenAddr, "tcp://localhost:1317")
-
 	viper.AddConfigPath(homeDir)
 	plasmaDir := filepath.Join(homeDir, "plasma.toml")
 	if _, err := os.Stat(plasmaDir); os.IsNotExist(err) {
-
 		config.WritePlasmaConfigFile(plasmaDir, config.DefaultPlasmaConfig())
 	}
 
@@ -69,18 +66,17 @@ func main() {
 		eth.ProveCmd(),
 		includeCmd,
 		client.LineBreak,
+
 		signCmd,
 		spendCmd,
 		client.LineBreak,
+
 		keys.KeysCmd(),
 		client.LineBreak,
+
 		versionCmd,
 	)
 
-	Execute()
-}
-
-func Execute() {
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)

client/plasmacli/query/account.go → client/plasmacli/query/balance.go

@@ -3,12 +3,10 @@ package query
 import (
 	"fmt"
 	ks "github.com/FourthState/plasma-mvp-sidechain/client/store"
-	"github.com/FourthState/plasma-mvp-sidechain/store"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/spf13/cobra"
-	"math/big"
 )
 
 func init() {
@@ -28,25 +26,23 @@ var balanceCmd = &cobra.Command{
 			return err
 		}
 
-		res, err := ctx.QuerySubspace(addr.Bytes(), "utxo")
+		total, err := Balance(ctx, addr)
 		if err != nil {
 			return err
 		}
 
-		total := big.NewInt(0)
-		utxo := store.UTXO{}
-		for _, pair := range res {
-			if err := rlp.DecodeBytes(pair.Value, &utxo); err != nil {
-				return err
-			}
-
-			if !utxo.Spent {
-				fmt.Printf("Position: %s , Amount: %d\n", utxo.Position, utxo.Output.Amount.Uint64())
-				total = total.Add(total, utxo.Output.Amount)
-			}
-		}
-
-		fmt.Printf("Total: %d\n", total.Uint64())
+		fmt.Printf("Address: %0x\n", addr)
+		fmt.Printf("Total: %s\n", total)
 		return nil
 	},
 }
+
+func Balance(ctx context.CLIContext, addr common.Address) (string, error) {
+	queryRoute := fmt.Sprintf("custom/utxo/balance/%s", addr.Hex())
+	data, err := ctx.Query(queryRoute, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return string(data), nil
+}

client/plasmacli/query/block.go

@@ -1,12 +1,11 @@
 package query
 
 import (
+	"encoding/json"
 	"fmt"
-	"github.com/FourthState/plasma-mvp-sidechain/plasma"
+	"github.com/FourthState/plasma-mvp-sidechain/store"
 	"github.com/cosmos/cosmos-sdk/client/context"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/spf13/cobra"
-	"math/big"
 	"strings"
 )
 
@@ -20,28 +19,32 @@ var blockCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		ctx := context.NewCLIContext().WithTrustNode(true)
-		blockNum, ok := new(big.Int).SetString(strings.TrimSpace(args[0]), 10)
-		if !ok {
-			return fmt.Errorf("block number must be provided in decimal format")
-		}
+		num := strings.TrimSpace(args[0])
 
-		key := append([]byte("block::"), blockNum.Bytes()...)
-		data, err := ctx.QueryStore(key, "plasma")
+		block, err := Block(ctx, num)
 		if err != nil {
-			fmt.Println("error querying store")
 			return err
 		}
-		if data == nil {
-			return fmt.Errorf("plasma block does not exist")
-		}
 
-		block := plasma.Block{}
-		if err := rlp.DecodeBytes(data, &block); err != nil {
-			fmt.Println("error decoding")
-			return err
-		}
+		fmt.Printf("Block Header: 0x%x\n", block.Header)
+		fmt.Printf("Transaction Count: %d, FeeAmount: %d\n", block.TxnCount, block.FeeAmount)
+		fmt.Printf("Tendermint BlockHeight: %d\n", block.TMBlockHeight)
 
-		fmt.Printf("Header: %x\nTxs: %d\nFee: %d\n", block.Header, block.TxnCount, block.FeeAmount)
 		return nil
 	},
 }
+
+func Block(ctx context.CLIContext, num string) (store.Block, error) {
+	queryPath := fmt.Sprintf("custom/plasma/block/%s", num)
+	data, err := ctx.Query(queryPath, nil)
+	if err != nil {
+		return store.Block{}, err
+	}
+
+	var block store.Block
+	if err := json.Unmarshal(data, &block); err != nil {
+		return store.Block{}, err
+	}
+
+	return block, nil
+}

client/plasmacli/query/info.go

@@ -1,12 +1,11 @@
 package query
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/FourthState/plasma-mvp-sidechain/store"
 	"github.com/cosmos/cosmos-sdk/client/context"
-	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/spf13/cobra"
 	"strings"
 )
@@ -20,46 +19,52 @@ var infoCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Short: "Information on owned utxos valid and invalid",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		ctx := context.NewCLIContext().WithCodec(codec.New())
+		ctx := context.NewCLIContext()
 		addrStr := strings.TrimSpace(args[0])
 		if !common.IsHexAddress(addrStr) {
 			return fmt.Errorf("Invalid address provided. Please use hex format")
 		}
+		addr := common.HexToAddress(addrStr)
+		fmt.Printf("Querying information for 0x%x\n\n", addr)
 
-		// query for all utxos owned by this address
-		res, err := ctx.QuerySubspace(common.HexToAddress(addrStr).Bytes(), "utxo")
+		utxos, err := Info(ctx, addr)
 		if err != nil {
 			return err
 		}
 
-		utxo := store.UTXO{}
-		for i, pair := range res {
-			if err := rlp.DecodeBytes(pair.Value, &utxo); err != nil {
-				return err
-			}
-
+		for i, utxo := range utxos {
 			fmt.Printf("UTXO %d\n", i)
-			fmt.Printf("Position: %s, Amount: %s, Spent: %t\n", utxo.Position, utxo.Output.Amount.String(), utxo.Spent)
-
+			fmt.Printf("Position: %s, Amount: %s, Spent: %t\nSpender Hash: %s\n", utxo.Tx.Position, utxo.Output.Output.Amount.String(), utxo.Output.Spent, utxo.Output.Spender)
+			fmt.Printf("Transaction Hash: 0x%x\nConfirmationHash: 0x%x\n", utxo.Tx.Transaction.TxHash(), utxo.Tx.ConfirmationHash)
 			// print inputs if applicable
-			inputAddresses := utxo.InputAddresses()
-			positions := utxo.InputPositions()
-			for i, _ := range inputAddresses {
-				fmt.Printf("Input Owner %d, Position: %s\n", i, positions[i])
-			}
-
-			// print spenders if applicable
-			spenderAddresses := utxo.SpenderAddresses()
-			positions = utxo.SpenderPositions()
-			for i, _ := range spenderAddresses {
-				fmt.Printf("Spender Owner %d, Position: %s\n", i, positions[i])
+			positions := utxo.Tx.Transaction.InputPositions()
+			for i, p := range positions {
+				fmt.Printf("Input %d Position: %s\n", i, p)
 			}
 
 			fmt.Printf("End UTXO %d info\n\n", i)
 		}
 
-		fmt.Println()
+		if len(utxos) == 0 {
+			fmt.Println("no information available for this address")
+		}
 
 		return nil
 	},
 }
+
+func Info(ctx context.CLIContext, addr common.Address) ([]store.QueryOutput, error) {
+	// query for all utxos owned by this address
+	queryRoute := fmt.Sprintf("custom/utxo/info/%s", addr.Hex())
+	data, err := ctx.Query(queryRoute, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var utxos []store.QueryOutput
+	if err := json.Unmarshal(data, &utxos); err != nil {
+		return nil, err
+	}
+
+	return utxos, nil
+}