func (args *ResendArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err = json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 1 { return shared.NewInsufficientParamsError(len(obj), 1) } data, err := json.Marshal(obj[0]) if err != nil { return shared.NewDecodeParamError("Unable to parse transaction object") } trans := new(tx) err = json.Unmarshal(data, trans) if err != nil { return shared.NewDecodeParamError("Unable to parse transaction object") } if trans == nil || trans.tx == nil { return shared.NewDecodeParamError("Unable to parse transaction object") } gasLimit, gasPrice := trans.GasLimit, trans.GasPrice if len(obj) > 1 && obj[1] != nil { if gp, ok := obj[1].(string); ok { gasPrice = gp } else { return shared.NewInvalidTypeError("gasPrice", "not a string") } } if len(obj) > 2 && obj[2] != nil { if gl, ok := obj[2].(string); ok { gasLimit = gl } else { return shared.NewInvalidTypeError("gasLimit", "not a string") } } args.Tx = trans args.GasPrice = gasPrice args.GasLimit = gasLimit return nil }
func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 2 { return shared.NewInsufficientParamsError(len(obj), 2) } var objstr string var ok bool if objstr, ok = obj[0].(string); !ok { return shared.NewInvalidTypeError("database", "not a string") } args.Database = objstr if objstr, ok = obj[1].(string); !ok { return shared.NewInvalidTypeError("key", "not a string") } args.Key = objstr if len(obj) > 2 { objstr, ok = obj[2].(string) if !ok { return shared.NewInvalidTypeError("value", "not a string") } args.Value = common.FromHex(objstr) } return nil }
func blockHeightFromJson(msg json.RawMessage, number *int64) error { var raw interface{} if err := json.Unmarshal(msg, &raw); err != nil { return shared.NewDecodeParamError(err.Error()) } return blockHeight(raw, number) }
func (args *NewSigArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } // Check for sufficient params if len(obj) < 1 { return shared.NewInsufficientParamsError(len(obj), 1) } from, ok := obj[0].(string) if !ok { return shared.NewInvalidTypeError("from", "not a string") } args.From = from if len(args.From) == 0 { return shared.NewValidationError("from", "is required") } data, ok := obj[1].(string) if !ok { return shared.NewInvalidTypeError("data", "not a string") } args.Data = data if len(args.Data) == 0 { return shared.NewValidationError("data", "is required") } return nil }
func (self *ethApi) GetLogs(req *shared.Request) (interface{}, error) { args := new(BlockFilterArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } return NewLogsRes(self.xeth.AllLogs(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics)), nil }
func (args *GetBlockByHashArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 2 { return shared.NewInsufficientParamsError(len(obj), 2) } argstr, ok := obj[0].(string) if !ok { return shared.NewInvalidTypeError("blockHash", "not a string") } args.BlockHash = argstr args.IncludeTxs = obj[1].(bool) if inclTx, ok := obj[1].(bool); ok { args.IncludeTxs = inclTx return nil } return shared.NewInvalidTypeError("includeTxs", "not a bool") }
func (self *ethApi) SubmitWork(req *shared.Request) (interface{}, error) { args := new(SubmitWorkArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } return self.xeth.RemoteMining().SubmitWork(args.Nonce, common.HexToHash(args.Digest), common.HexToHash(args.Header)), nil }
func (self *ethApi) UninstallFilter(req *shared.Request) (interface{}, error) { args := new(FilterIdArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } return self.xeth.UninstallFilter(args.Id), nil }
func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err = json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 3 { return shared.NewInsufficientParamsError(len(obj), 3) } var objstr string var ok bool if objstr, ok = obj[0].(string); !ok { return shared.NewInvalidTypeError("nonce", "not a string") } args.Nonce = common.String2Big(objstr).Uint64() if objstr, ok = obj[1].(string); !ok { return shared.NewInvalidTypeError("header", "not a string") } args.Header = objstr if objstr, ok = obj[2].(string); !ok { return shared.NewInvalidTypeError("digest", "not a string") } args.Digest = objstr return nil }
func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 1 { return shared.NewInsufficientParamsError(len(obj), 1) } addstr, ok := obj[0].(string) if !ok { return shared.NewInvalidTypeError("address", "not a string") } args.Address = addstr if len(obj) > 1 { if err := blockHeight(obj[1], &args.BlockNumber); err != nil { return err } } else { args.BlockNumber = -1 } return nil }
func (args *WaitForBlockArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) > 2 { return fmt.Errorf("waitForArgs needs 0, 1, 2 arguments") } // default values when not provided args.MinHeight = -1 args.Timeout = -1 if len(obj) >= 1 { var minHeight *big.Int if minHeight, err = numString(obj[0]); err != nil { return err } args.MinHeight = int(minHeight.Int64()) } if len(obj) >= 2 { timeout, err := numString(obj[1]) if err != nil { return err } args.Timeout = int(timeout.Int64()) } return nil }
func (self *ethApi) SendTransaction(req *shared.Request) (interface{}, error) { args := new(NewTxArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } // nonce may be nil ("guess" mode) var nonce string if args.Nonce != nil { nonce = args.Nonce.String() } var gas, price string if args.Gas != nil { gas = args.Gas.String() } if args.GasPrice != nil { price = args.GasPrice.String() } v, err := self.xeth.Transact(args.From, args.To, nonce, args.Value.String(), gas, price, args.Data) if err != nil { return nil, err } return v, nil }
func (self *ethApi) SignTransaction(req *shared.Request) (interface{}, error) { args := new(NewTxArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } // nonce may be nil ("guess" mode) var nonce string if args.Nonce != nil { nonce = args.Nonce.String() } var gas, price string if args.Gas != nil { gas = args.Gas.String() } if args.GasPrice != nil { price = args.GasPrice.String() } tx, err := self.xeth.SignTransaction(args.From, args.To, nonce, args.Value.String(), gas, price, args.Data) if err != nil { return nil, err } data, err := rlp.EncodeToBytes(tx) if err != nil { return nil, err } return JsonTransaction{"0x" + common.Bytes2Hex(data), newTx(tx)}, nil }
func (args *SubmitHashRateArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 2 { return shared.NewInsufficientParamsError(len(obj), 2) } arg0, ok := obj[0].(string) if !ok { return shared.NewInvalidTypeError("hash", "not a string") } args.Id = arg0 arg1, ok := obj[1].(string) if !ok { return shared.NewInvalidTypeError("rate", "not a string") } args.Rate = common.String2Big(arg1).Uint64() return nil }
func (args *UnlockAccountArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } args.Duration = 0 if len(obj) < 1 { return shared.NewInsufficientParamsError(len(obj), 1) } if addrstr, ok := obj[0].(string); ok { args.Address = addrstr } else { return shared.NewInvalidTypeError("address", "not a string") } if len(obj) >= 2 && obj[1] != nil { if passphrasestr, ok := obj[1].(string); ok { args.Passphrase = &passphrasestr } else { return shared.NewInvalidTypeError("passphrase", "not a string") } } if len(obj) >= 3 && obj[2] != nil { if duration, ok := obj[2].(float64); ok { args.Duration = int(duration) } } return nil }
func (self *ethApi) SubmitHashrate(req *shared.Request) (interface{}, error) { args := new(SubmitHashRateArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return false, shared.NewDecodeParamError(err.Error()) } self.xeth.RemoteMining().SubmitHashrate(common.HexToHash(args.Id), args.Rate) return true, nil }
func (self *ethApi) GetFilterLogs(req *shared.Request) (interface{}, error) { args := new(FilterIdArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } return NewLogsRes(self.xeth.Logs(args.Id)), nil }
func (self *ethApi) GetStorageAt(req *shared.Request) (interface{}, error) { args := new(GetStorageAtArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } return self.xeth.AtStateNum(args.BlockNumber).StorageAt(args.Address, args.Key), nil }
func (self *ethApi) GetData(req *shared.Request) (interface{}, error) { args := new(GetDataArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } v := self.xeth.AtStateNum(args.BlockNumber).CodeAtBytes(args.Address) return newHexData(v), nil }
func (self *adminApi) Sleep(req *shared.Request) (interface{}, error) { args := new(SleepArgs) if err := self.coder.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } time.Sleep(time.Duration(args.S) * time.Second) return nil, nil }
func (self *adminApi) Verbosity(req *shared.Request) (interface{}, error) { args := new(VerbosityArgs) if err := self.coder.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } glog.SetV(args.Level) return true, nil }
func (self *debugApi) PrintBlock(req *shared.Request) (interface{}, error) { args := new(BlockNumArg) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } block := self.xeth.EthBlockByNumber(args.BlockNumber) return fmt.Sprintf("%s", block), nil }
func (self *debugApi) SetHead(req *shared.Request) (interface{}, error) { args := new(BlockNumArg) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } self.expanse.BlockChain().SetHead(uint64(args.BlockNumber)) return nil, nil }
func (self *ethApi) NewFilter(req *shared.Request) (interface{}, error) { args := new(BlockFilterArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } id := self.xeth.NewLogFilter(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics) return newHexNum(big.NewInt(int64(id)).Bytes()), nil }
func (self *ethApi) GetTransactionCount(req *shared.Request) (interface{}, error) { args := new(GetTxCountArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } count := self.xeth.AtStateNum(args.BlockNumber).TxCountAt(args.Address) return fmt.Sprintf("%#x", count), nil }
func (self *personalApi) NewAccount(req *shared.Request) (interface{}, error) { args := new(NewAccountArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } am := self.expanse.AccountManager() acc, err := am.NewAccount(args.Passphrase) return acc.Address.Hex(), err }
func (self *ethApi) GetNatSpec(req *shared.Request) (interface{}, error) { args := new(NewTxArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } var jsontx = fmt.Sprintf(`{"params":[{"to":"%s","data": "%s"}]}`, args.To, args.Data) notice := natspec.GetNotice(self.xeth, jsontx, self.expanse.HTTPClient()) return notice, nil }
func (self *ethApi) GetBlockByHash(req *shared.Request) (interface{}, error) { args := new(GetBlockByHashArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } block := self.xeth.EthBlockByHash(args.BlockHash) if block == nil { return nil, nil } return NewBlockRes(block, self.xeth.Td(block.Hash()), args.IncludeTxs), nil }
func (self *ethApi) Sign(req *shared.Request) (interface{}, error) { args := new(NewSigArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } v, err := self.xeth.Sign(args.From, args.Data, false) if err != nil { return nil, err } return v, nil }
func (self *ethApi) GetBlockTransactionCountByHash(req *shared.Request) (interface{}, error) { args := new(HashArgs) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, shared.NewDecodeParamError(err.Error()) } block := self.xeth.EthBlockByHash(args.Hash) if block == nil { return nil, nil } return fmt.Sprintf("%#x", len(block.Transactions())), nil }