fixmes

pkg/eth/eth.go

@@ -44,10 +44,12 @@ func (t *TransactionReq) IsCallContract() bool {
 	return t.To != "" && t.Data != ""
 }
 
+// FIXME: GetGas -> GasHex
 func (t *TransactionReq) GetGas() string {
 	return t.Gas.Hex()
 }
 
+// FIXME: GetGasPrice -> GasPriceHex
 func (t *TransactionReq) GetGasPrice() string {
 	return t.GasPrice.Hex()
 }
@@ -123,6 +125,7 @@ type (
 	}
 )
 
+// FIXME: ETHInt
 type EthInt big.Int
 
 func (i *EthInt) Hex() string {
@@ -139,6 +142,11 @@ func (i *EthInt) MarshalJSON() ([]byte, error) {
 	return json.Marshal(i.ToBigInt())
 }
 
+// FIXME: extract parsers into constructors:
+// ETHIntFromNumber
+// ETHIntFromIntger
+
+// UnmarshalJSON needs to be able to parse ETHInt from both hex string or number
 func (i *EthInt) UnmarshalJSON(data []byte) (err error) {
 	if len(data) == 0 {
 		return errors.New("data must not be empty")

pkg/qtum/client.go

@@ -19,6 +19,14 @@ import (
 	"github.com/pkg/errors"
 )
 
+// FIXME: Abstract all API calls into a RPC call helper. See:
+// https://github.com/hayeah/eostools/blob/8e1d0d48c74b7ca6a74b132d619a4e7f8673d26a/eos-actions/main.go#L16
+
+// FIXME: We can probably remove all methods from Client, and only provide a single `Request` method
+
+// FIXME: Define all RPC types in rpcTypes.go
+
+// FIXME: rename Client -> RPC or RPCClient
 type Client struct {
 	rpcURL  string
 	doer    doer
@@ -68,6 +76,7 @@ func SetLogger(l log.Logger) func(*Client) error {
 	}
 }
 
+// FIXME: GetHexAddress -> Base58AddressToHex
 func (c *Client) GetHexAddress(addr string) (string, error) {
 	r := c.NewRPCRequest(MethodGethexaddress)
 	r.Params = json.RawMessage(fmt.Sprintf(`["%s"]`, addr))
@@ -102,6 +111,12 @@ func (c *Client) FromHexAddress(addr string) (string, error) {
 	return qtumAddr, nil
 }
 
+// FIXME: Define the types for all API methods: [methodName]Request, [methodName]Response
+//
+// type GetTransactionReceiptResponse []struct {
+// 	// A int `json:"a"`
+// }
+
 func (c *Client) GetTransactionReceipt(txHash string) (*TransactionReceipt, error) {
 	r := c.NewRPCRequest(MethodGettransactionreceipt)
 	r.Params = json.RawMessage(fmt.Sprintf(`["%s"]`, txHash))
@@ -127,6 +142,7 @@ func (c *Client) GetTransactionReceipt(txHash string) (*TransactionReceipt, erro
 
 	return receipt, nil
 }
+
 func (c *Client) DecodeRawTransaction(hex string) (*DecodedRawTransaction, error) {
 	r := c.NewRPCRequest(MethodDecoderawtransaction)
 	r.Params = json.RawMessage(fmt.Sprintf(`["%s"]`, hex))

pkg/qtum/qtum.go

@@ -1,17 +1,19 @@
 package qtum
 
 import (
-	"errors"
 	"fmt"
 	"math/big"
 	"strings"
+
+	"github.com/pkg/errors"
 )
 
 const (
 	Version = "1.0"
 )
 
 const (
+	// FIXME: camel case. MethodGethexaddress -> MethodGetHexAddress
 	MethodGethexaddress         = "gethexaddress"
 	MethodFromhexaddress        = "fromhexaddress"
 	MethodSendtocontract        = "sendtocontract"
@@ -27,7 +29,16 @@ const (
 	MethodWaitforlogs           = "waitforlogs"
 )
 
+// FIXME: rename TransactionReceipt -> GetTransactionReceiptResponse
+// FIXME: rename all other qtum RPC types
+// FIXME: move all RPC types into its own file.
+// FIXME: (optional) add RPC examples to each struct
 type (
+	/* example:
+	{
+		"blockhash": "afafafa..."
+	}
+	*/
 	TransactionReceipt struct {
 		BlockHash         string `json:"blockHash"`
 		BlockNumber       uint64 `json:"blockNumber"`
@@ -108,6 +119,9 @@ type (
 		Hex               string               `json:"hex"`
 	}
 
+	// FIXME: extract asm to its own file. btcasm.go
+
+	// ASM is Bitcoin Script extended by qtum to support smart contracts
 	ASM struct {
 		VMVersion  string
 		GasLimit   string
@@ -116,12 +130,13 @@ type (
 	}
 	CallASM struct {
 		ASM
+		// FIXME: EncodedABI -> CallData
 		EncodedABI      string
 		ContractAddress string
 	}
-
 	CreateASM struct {
 		ASM
+		// FIXME: EncodedABI -> CallData
 		EncodedABI string
 	}
 
@@ -162,6 +177,7 @@ type (
 func ParseCallASM(asm string) (*CallASM, error) {
 	parts := strings.Split(asm, " ")
 	if len(parts) < 6 {
+		// FIXME: typo: sam -> ASM
 		return nil, errors.New("invalid call sam")
 	}
 
@@ -180,6 +196,7 @@ func ParseCallASM(asm string) (*CallASM, error) {
 func ParseCreateASM(asm string) (*CreateASM, error) {
 	parts := strings.Split(asm, " ")
 	if len(parts) < 5 {
+		// FIXME: typo: sam -> ASM
 		return nil, errors.New("invalid create sam")
 	}
 
@@ -194,10 +211,12 @@ func ParseCreateASM(asm string) (*CreateASM, error) {
 	}, nil
 }
 
+// FIXME: rename GetGasPrice -> GasPrice
 func (asm *ASM) GetGasPrice() (*big.Int, error) {
 	return stringToBigInt(asm.GasPrice)
 }
 
+// FIXME: rename GetGasLimit -> GasLimit
 func (asm *ASM) GetGasLimit() (*big.Int, error) {
 	return stringToBigInt(asm.GasLimit)
 }
@@ -214,7 +233,8 @@ func stringToBigInt(str string) (*big.Int, error) {
 	var success bool
 	v := new(big.Int)
 	if v, success = v.SetString(str, 10); !success {
-		return nil, errors.New(fmt.Sprintf("failed to parse str: %s to big.Int", str))
+		// FIXME: use errors.Errorf
+		return nil, errors.New(fmt.Sprintf("Failed to parse big.Int: %s", str))
 	}
 	return v, nil
 }

pkg/rpc/jsonrpc.go

@@ -5,11 +5,16 @@ import (
 	"fmt"
 )
 
+// FIXME: move to qtum package
 const (
 	ErrInvalid          = 150
 	ErrUnknownOperation = 151
 )
 
+// FIXME: rename package to jsonrpc
+// FIXME: remove JSONRPC prefix for JSONRPCRequest, JSONRPCResult
+// FIXME: this package seems kinda pointless
+
 type JSONRPCRequest struct {
 	JSONRPC string          `json:"jsonrpc"`
 	Method  string          `json:"method"`
@@ -30,6 +35,7 @@ type SuccessJSONRPCResult struct {
 	ID        json.RawMessage `json:"id"`
 }
 
+// FIXME: move this to qtum package
 type JSONRPCError struct {
 	Code    int    `json:"code"`
 	Message string `json:"message"`

pkg/server/handler.go

@@ -11,14 +11,20 @@ import (
 	"github.com/pkg/errors"
 )
 
+// FIXME: refactor this method. move the `request -> transform -> response` to transformer package
 func httpHandler(c *myCtx) (interface{}, error) {
 	rpcReq := c.rpcReq
 
+	// FIXME: move to transformer
 	switch rpcReq.Method {
 	case "personal_unlockAccount":
 		return true, nil
 	}
 
+	// FIXME:
+	// proxyRes, err = TransformRequest.Proxy(rpcReq)
+	// output proxyRes as JSON. done.
+
 	level.Info(c.logger).Log("msg", "before transform request", "method", rpcReq.Method, "params", []byte(rpcReq.Params))
 	responseTransformer, err := c.server.transformerManager.TransformRequest(rpcReq)
 

pkg/server/server.go

@@ -20,6 +20,8 @@ type Server struct {
 	echo               *echo.Echo
 }
 
+// FIXME: define a StartServer/main function to do dependency injection. Constructor should be simple.
+
 func New(qtumRPC string, addr string, opts ...Option) (*Server, error) {
 	opts = append(opts, setQtumRPC(qtumRPC), setAddress(addr))
 
@@ -35,6 +37,8 @@ func New(qtumRPC string, addr string, opts ...Option) (*Server, error) {
 		}
 	}
 
+	// FIXME: dependency injection: pass client an transformer into constructor as parameters
+
 	p.qtumClient, err = qtum.NewClient(
 		qtumRPC,
 		qtum.SetLogger(p.logger),

pkg/transformer/callcontract.go

@@ -10,6 +10,63 @@ import (
 	"github.com/dcb9/janus/pkg/rpc"
 )
 
+// method: eth_call
+//
+// eth request -> qtum request
+// call qtum rpc
+// qtum reponse -> eth response
+
+func (m *Manager) proxyRPC(req *rpc.JSONRPCRequest) (interface{}, error) {
+	switch req.Method {
+	case "eth_call":
+		var req eth.CallRequest
+		err := unmarshalRequest(req.Params, &req)
+		if err != nil {
+			return nil, err
+		}
+		return m.proxyETHCall(req)
+	default:
+		return errors.New("unsupported method")
+	}
+}
+
+type Proxy interface {
+	request(ethreq interface{}) (interface{}, error)
+}
+
+// FIXME: rename file to eth_call.go
+// proxy eth_call
+
+type ProxyETHCall struct{}
+
+func (p *ProxyETHCall) request(rawreq *rpc.JSONRPCRequest) (interface{}, error) {
+	var req eth.CallRequest
+	err := unmarshalRequest(rawreq.Params, &req)
+	if err != nil {
+		return nil, err
+	}
+	return p.proxyInternal(req)
+}
+
+func (p *ProxyETHCall) requestInternal(ethreq *eth.CallRequest) (*eth.CallResponse, error) {
+	// eth req -> qtum req
+	qtumreq, err = p.ToRequest(ethreq)
+
+	var qtumres qtum.CallContract
+	err = p.rpc.Request(qtumreq, &qtumres)
+
+	// qtum res -> eth res
+	ethres, err = p.ToResponse(ethreq)
+
+	return ethres, err
+}
+
+func (p *ProxyETHCall) ToRequest(ethreq *eth.CallRequest) (*qtum.CallContract, error) {
+}
+
+func (p *ProxyETHCall) ToResponse(res *qtum.CallResponse) (*eth.CallResponse, error) {
+}
+
 func (m *Manager) Call(req *rpc.JSONRPCRequest) (ResponseTransformerFunc, error) {
 	var params []json.RawMessage
 	if err := unmarshalRequest(req.Params, &params); err != nil {
@@ -19,36 +76,11 @@ func (m *Manager) Call(req *rpc.JSONRPCRequest) (ResponseTransformerFunc, error)
 		return nil, errors.New("params must be set")
 	}
 
+	// FIXME: rename to eth.CallRequest
 	var tx eth.TransactionCallReq
 	if err := unmarshalRequest(params[0], &tx); err != nil {
 		return nil, err
 	}
-	gasLimit, _, err := EthGasToQtum(&tx)
-	if err != nil {
-		return nil, err
-	}
-
-	from := tx.From
-
-	if IsEthHexAddress(from) {
-		from, err = m.qtumClient.FromHexAddress(RemoveHexPrefix(from))
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	newParams, err := json.Marshal([]interface{}{
-		RemoveHexPrefix(tx.To),
-		RemoveHexPrefix(tx.Data),
-		from,
-		gasLimit,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	req.Params = newParams
-	req.Method = qtum.MethodCallcontract
 
 	//Qtum RPC
 	// callcontract "address" "data" ( address )