From 6227c446d3a9871f66a84763adff83091022686f Mon Sep 17 00:00:00 2001 From: "Owain G. Ainsworth" Date: Tue, 22 Oct 2013 15:12:12 +0100 Subject: [PATCH] Add a framewowrk for parsing and creating json commands. Initial prototype for one command mostly from jrick, with discussion with me and jcv. Other commands mocked up in a couple of long boring days by yours truly. Code isn't fully tested yet so may well still be buggy in the type conversions. Test will be added over the next few days to get this up to snuff. --- jsoncmd.go | 6464 +++++++++++++++++++++++++++++++++++++++++++++++ jsoncmd_test.go | 193 ++ 2 files changed, 6657 insertions(+) create mode 100644 jsoncmd.go create mode 100644 jsoncmd_test.go diff --git a/jsoncmd.go b/jsoncmd.go new file mode 100644 index 00000000..0fcf1ce9 --- /dev/null +++ b/jsoncmd.go @@ -0,0 +1,6464 @@ +// Copyright (c) 2013 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package btcjson + +import ( + "encoding/json" + "errors" +) + +// ErrTooManyOptArgs describes an error where too many optional +// arguments were passed when creating a new Cmd. +var ErrTooManyOptArgs = errors.New("too many optional arguments") + +// ErrWrongNumberOfParams describes an error where an incorrect number of +// parameters are found in an unmarshalled command. +var ErrWrongNumberOfParams = errors.New("incorrect number of parameters") + +// Cmd is an interface for all Bitcoin JSON API commands to marshal +// and unmarshal as a JSON object. +type Cmd interface { + json.Marshaler + json.Unmarshaler + Id() interface{} + Method() string +} + +// RawCmd is a type for unmarshaling raw commands into before the +// custom command type is set. Other packages may register their +// own RawCmd to Cmd converters by calling RegisterCustomCmd. +type RawCmd struct { + Jsonrpc string `json:"jsonrpc"` + Id interface{} `json:"id"` + Method string `json:"method"` + Params []interface{} `json:"params"` +} + +// ParseRawCmd is a function to create a custom Cmd from a RawCmd. +type RawCmdParser func(*RawCmd) (Cmd, error) + +var customCmds = make(map[string]RawCmdParser) + +// RegisterCustomCmd registers a custom RawCmd parsing func for a +// non-standard Bitcoin command. +func RegisterCustomCmd(method string, parser RawCmdParser) { + customCmds[method] = parser +} + +// ParseMarshaledCmd parses a raw command and unmarshals as a Cmd. +// Code that reads and handles commands should switch on the type and +// type assert as the particular commands supported by the program. +func ParseMarshaledCmd(b []byte) (Cmd, error) { + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return nil, err + } + + // Return a custom command type for recognized + var cmd Cmd = nil + switch r.Method { + case "addmultisigaddress": + cmd = new(AddMultisigAddressCmd) + + case "addnode": + cmd = new(AddNodeCmd) + + case "backupwallet": + cmd = new(BackupWalletCmd) + + case "createmultisig": + cmd = new(CreateMultisigCmd) + + case "createrawtransaction": + cmd = new(CreateRawTransactionCmd) + + case "decoderawtransaction": + cmd = new(DecodeRawTransactionCmd) + + case "decodescript": + cmd = new(DecodeScriptCmd) + + case "dumpprivkey": + cmd = new(DumpPrivKeyCmd) + + case "dumpwallet": + cmd = new(DumpWalletCmd) + + case "encryptwallet": + cmd = new(EncryptWalletCmd) + + case "getaccount": + cmd = new(GetAccountCmd) + + case "getaccountaddress": + cmd = new(GetAccountAddressCmd) + + case "getaddednodeinfo": + cmd = new(GetAddedNodeInfoCmd) + + case "getaddressesbyaccount": + cmd = new(GetAddressesByAccountCmd) + + case "getbalance": + cmd = new(GetBalanceCmd) + + case "getbestblockhash": + cmd = new(GetBestBlockHashCmd) + + case "getblock": + cmd = new(GetBlockCmd) + + case "getblockcount": + cmd = new(GetBlockCountCmd) + + case "getblockhash": + cmd = new(GetBlockHashCmd) + + case "getblocktemplate": + cmd = new(GetBlockTemplateCmd) + + case "getconnectioncount": + cmd = new(GetConnectionCountCmd) + + case "getdifficulty": + cmd = new(GetDifficultyCmd) + + case "getgenerate": + cmd = new(GetGenerateCmd) + + case "gethashespersec": + cmd = new(GetHashesPerSecCmd) + + case "getinfo": + cmd = new(GetInfoCmd) + + case "getnettotals": + cmd = new(GetNetTotalsCmd) + + case "getnetworkhashps": + cmd = new(GetNetworkHashPSCmd) + + case "getnewaddress": + cmd = new(GetNewAddressCmd) + + case "getpeerinfo": + cmd = new(GetPeerInfoCmd) + + case "getrawchangeaddress": + cmd = new(GetRawChangeAddressCmd) + + case "getrawmempool": + cmd = new(GetRawMempoolCmd) + + case "getrawtransaction": + cmd = new(GetRawTransactionCmd) + + case "getreceivedbyaccount": + cmd = new(GetReceivedByAccountCmd) + + case "getreceivedbyaddress": + cmd = new(GetReceivedByAddressCmd) + + case "gettransaction": + cmd = new(GetTransactionCmd) + + case "gettxout": + cmd = new(GetTxOutCmd) + + case "gettxoutsetinfo": + cmd = new(GetTxOutSetInfoCmd) + + case "getwork": + cmd = new(GetWorkCmd) + + case "help": + cmd = new(HelpCmd) + + case "importprivkey": + cmd = new(ImportPrivKeyCmd) + + case "importwallet": + cmd = new(ImportWalletCmd) + + case "keypoolrefill": + cmd = new(KeyPoolRefillCmd) + + case "listaccounts": + cmd = new(ListAccountsCmd) + + case "listaddressgroupings": + cmd = new(ListAddressGroupingsCmd) + + case "listlockunspent": + cmd = new(ListLockUnspentCmd) + + case "listreceivedbyaccount": + cmd = new(ListReceivedByAccountCmd) + + case "listreceivedbyaddress": + cmd = new(ListReceivedByAddressCmd) + + case "listsinceblock": + cmd = new(ListSinceBlockCmd) + + case "listtransactions": + cmd = new(ListTransactionsCmd) + + case "listunspent": + cmd = new(ListUnspentCmd) + + case "lockunspent": + cmd = new(LockUnspentCmd) + + case "move": + cmd = new(MoveCmd) + + case "ping": + cmd = new(PingCmd) + + case "sendfrom": + cmd = new(SendFromCmd) + + case "sendmany": + cmd = new(SendManyCmd) + + case "sendrawtransaction": + cmd = new(SendRawTransactionCmd) + + case "sendtoaddress": + cmd = new(SendToAddressCmd) + + case "setaccount": + cmd = new(SetAccountCmd) + + case "setgenerate": + cmd = new(SetGenerateCmd) + + case "settxfee": + cmd = new(SetTxFeeCmd) + + case "signmessage": + cmd = new(SignMessageCmd) + + case "signrawtransaction": + cmd = new(SignRawTransactionCmd) + + case "stop": + cmd = new(StopCmd) + + case "submitblock": + cmd = new(SubmitBlockCmd) + + case "validateaddress": + cmd = new(ValidateAddressCmd) + + case "verifychain": + cmd = new(VerifyChainCmd) + + case "verifymessage": + cmd = new(VerifyMessageCmd) + + case "walletlock": + cmd = new(WalletLockCmd) + + case "walletpassphrase": + cmd = new(WalletPassphraseCmd) + + case "walletpassphrasechange": + cmd = new(WalletPassphraseChangeCmd) + + default: + // None of the standard Bitcoin RPC methods matched. Try + // registered custom commands. + if f, ok := customCmds[r.Method]; ok { + return f(&r) + } + } + + if cmd == nil { + return nil, errors.New("unimplemented") + } + + // If we get here we have a cmd that can unmarshal itself. + if err := cmd.UnmarshalJSON(b); err != nil { + return nil, err + } else { + return cmd, nil + } +} + +// AddMultisigAddressCmd is a type handling custom marshaling and +// unmarshaling of addmultisigaddress JSON RPC commands. +type AddMultisigAddressCmd struct { + id interface{} + NRequired int + Keys []string + Account string +} + +// Enforce that AddMultisigAddress satisifies the Cmd interface. +var _ Cmd = &AddMultisigAddressCmd{} + +// NewAddMultisigAddressCmd creates a new AddMultisigAddressCmd, +// parsing the optional arguments optArgs which may be either empty or an +// optional account name. +func NewAddMultisigAddressCmd(id interface{}, nRequired int, keys []string, + optArgs ...string) (*AddMultisigAddressCmd, error) { + // Optional parameters set to their defaults. + var account string + + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + account = optArgs[0] + } + + return &AddMultisigAddressCmd{ + id: id, + NRequired: nRequired, + Keys: keys, + Account: account, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *AddMultisigAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *AddMultisigAddressCmd) Method() string { + return "addmultisigaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *AddMultisigAddressCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "addmultisigaddress", + Id: cmd.id, + Params: []interface{}{ + cmd.NRequired, + cmd.Keys, + }, + } + + if cmd.Account != "" { + raw.Params = append(raw.Params, cmd.Account) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *AddMultisigAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) < 2 || len(r.Params) > 3 { + return ErrWrongNumberOfParams + } + nRequired, ok := r.Params[0].(float64) + if !ok { + return errors.New("first parameter nrequired must be a number") + } + ikeys, ok := r.Params[1].([]interface{}) + if !ok { + return errors.New("second parameter keys must be an array") + } + keys := make([]string, len(ikeys)) + for i, val := range(ikeys) { + keys[i], ok = val.(string) + if !ok { + return errors.New("second parameter keys must be an array of strings") + } + } + var account string + if len(r.Params) > 2 { + account, ok = r.Params[2].(string) + if !ok { + return errors.New("third (optional) parameter account must be a string") + } + } + newCmd, err := NewAddMultisigAddressCmd(r.Id, int(nRequired), keys, + account) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// AddNodeCmd is a type handling custom marshaling and +// unmarshaling of addmultisigaddress JSON RPC commands. +type AddNodeCmd struct { + id interface{} + Addr string + SubCmd string // One of "add","remove","onetry". TODO(oga) enum? +} + +// Enforce that AddNodeCmd satisifies the Cmd interface. +var _ Cmd = &AddNodeCmd{} + +// NewAddNodeCmd creates a new AddNodeCmd for the given address and subcommand. +func NewAddNodeCmd(id interface{}, addr string, subcmd string) ( + *AddNodeCmd, error) { + + switch subcmd { + case "add": + // fine + case "remove": + // fine + case "onetry": + // fine + default: + return nil, errors.New("Invalid subcommand for addnode") + } + + return &AddNodeCmd{ + id: id, + Addr: addr, + SubCmd: subcmd, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *AddNodeCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *AddNodeCmd) Method() string { + return "addnode" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *AddNodeCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "addnode", + Id: cmd.id, + Params: []interface{}{ + cmd.Addr, + cmd.SubCmd, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *AddNodeCmd) UnmarshalJSON(b []byte) error { + // Unmarshal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + addr, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter addr must be a string") + } + subcmd, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter subcmd must be a string") + } + newCmd, err := NewAddNodeCmd(r.Id, addr, subcmd) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// BackupWalletCmd is a type handling custom marshaling and +// unmarshaling of backupwallet JSON RPC commands. +type BackupWalletCmd struct { + id interface{} + Destination string +} + +// Enforce that BackupWalletCmd satisifies the Cmd interface. +var _ Cmd = &BackupWalletCmd{} + +// NewBackupWalletCmd creates a new BackupWalletCmd. +func NewBackupWalletCmd(id interface{}, path string) (*BackupWalletCmd, error) { + + return &BackupWalletCmd{ + id: id, + Destination: path, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *BackupWalletCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *BackupWalletCmd) Method() string { + return "backupwallet" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *BackupWalletCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "backupwallet", + Id: cmd.id, + Params: []interface{}{ + cmd.Destination, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *BackupWalletCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + destination, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter desitnation must be a string") + } + newCmd, err := NewBackupWalletCmd(r.Id, destination) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// CreateMultisigCmd is a type handling custom marshaling and +// unmarshaling of createmultisig JSON RPC commands. +type CreateMultisigCmd struct { + id interface{} + NRequired int + Keys []string +} + +// Enforce that AddMultisigAddress satisifies the Cmd interface. +var _ Cmd = &CreateMultisigCmd{} + +// NewCreateMultisigCmd creates a new CreateMultisigCmd, +// parsing the optional arguments optArgs. +func NewCreateMultisigCmd(id interface{}, nRequired int, keys []string) (*CreateMultisigCmd, error) { + return &CreateMultisigCmd{ + id: id, + NRequired: nRequired, + Keys: keys, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *CreateMultisigCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *CreateMultisigCmd) Method() string { + return "createmultisig" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *CreateMultisigCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "createmultisig", + Id: cmd.id, + Params: []interface{}{ + cmd.NRequired, + cmd.Keys, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *CreateMultisigCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + nRequired, ok := r.Params[0].(float64) + if !ok { + return errors.New("first parameter nrequired must be a number") + } + + ikeys, ok := r.Params[1].([]interface{}) + if !ok { + return errors.New("second parameter keys must be an array") + } + keys := make([]string, len(ikeys)) + for i, val := range(ikeys) { + keys[i], ok = val.(string) + if !ok { + return errors.New("second parameter keys must be an array of strings") + } + } + + newCmd, err := NewCreateMultisigCmd(r.Id, int(nRequired), keys) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// TransactionInput represents the inputs to a transaction. Specifically a +// transactionsha and output number pair. +type TransactionInput struct { + Txid string `json:"txid"` + Vout int `json:"vout"` +} + +// CreateRawTransactionCmd is a type handling custom marshaling and +// unmarshaling of createrawtransaction JSON RPC commands. +type CreateRawTransactionCmd struct { + id interface{} + Inputs []TransactionInput + Amounts map[string]int64 +} + +// Enforce that CreateRawTransactionCmd satisifies the Cmd interface. +var _ Cmd = &CreateRawTransactionCmd{} + +// NewCreateRawTransactionCmd creates a new CreateRawTransactionCmd. +func NewCreateRawTransactionCmd(id interface{}, inputs []TransactionInput, amounts map[string]int64) (*CreateRawTransactionCmd, error) { + return &CreateRawTransactionCmd{ + id: id, + Inputs: inputs, + Amounts: amounts, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *CreateRawTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *CreateRawTransactionCmd) Method() string { + return "createrawtransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *CreateRawTransactionCmd) MarshalJSON() ([]byte, error) { + floatAmount := make(map[string]float64) + + for k, v := range cmd.Amounts { + floatAmount[k] = float64(v) / 1e8 + } + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "createrawtransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.Inputs, + floatAmount, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *CreateRawTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + iinputs, ok := r.Params[0].([]interface{}) + if !ok { + return errors.New("first parameter inputs must be an array") + } + inputs := make([]TransactionInput, len(iinputs)) + for i, iv := range iinputs { + v, ok := iv.(map[string]interface{}) + if !ok { + return errors.New("first parameter inputs must be an array of objects") + } + + if len(v) != 2 { + return errors.New("input with wrong number of members") + } + txid, ok := v["txid"] + if !ok { + return errors.New("input without txid") + } + inputs[i].Txid, ok = txid.(string) + if !ok { + return errors.New("input txid isn't a string") + } + + vout, ok := v["vout"] + if !ok { + return errors.New("input without vout") + } + fvout, ok := vout.(float64) + if !ok { + return errors.New("input vout not a number") + } + inputs[i].Vout = int(fvout) + } + cmd.Inputs = inputs + famounts, ok := r.Params[1].(map[string]interface{}) + if !ok { + return errors.New("second parameter keys must be a map") + } + + amounts := make(map[string]int64) + for k, v := range famounts { + fv, ok := v.(float64) + if !ok { + return errors.New("second parameter keys must be a number map") + } + var err error + amounts[k], err = JSONToAmount(fv) + if err != nil { + return err + } + } + + newCmd, err := NewCreateRawTransactionCmd(r.Id, inputs, amounts) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// DecodeRawTransactionCmd is a type handling custom marshaling and +// unmarshaling of decoderawtransaction JSON RPC commands. +type DecodeRawTransactionCmd struct { + id interface{} + HexTx string +} + +// Enforce that DecodeRawTransactionCmd satisifies the Cmd interface. +var _ Cmd = &DecodeRawTransactionCmd{} + +// NewDecodeRawTransactionCmd creates a new DecodeRawTransactionCmd. +func NewDecodeRawTransactionCmd(id interface{}, hextx string) (*DecodeRawTransactionCmd, error) { + return &DecodeRawTransactionCmd{ + id: id, + HexTx: hextx, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *DecodeRawTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *DecodeRawTransactionCmd) Method() string { + return "decoderawtransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *DecodeRawTransactionCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "decoderawtransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.HexTx, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *DecodeRawTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + hextx, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter hextx must be an array of objects") + } + + newCmd, err := NewDecodeRawTransactionCmd(r.Id, hextx) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// DecodeScriptCmd is a type handling custom marshaling and +// unmarshaling of decodescript JSON RPC commands. +type DecodeScriptCmd struct { + id interface{} + HexScript string +} + +// Enforce that DecodeScriptCmd satisifies the Cmd interface. +var _ Cmd = &DecodeScriptCmd{} + +// NewDecodeScriptCmd creates a new DecodeScriptCmd. +func NewDecodeScriptCmd(id interface{}, hexscript string) (*DecodeScriptCmd, error) { + return &DecodeScriptCmd{ + id: id, + HexScript: hexscript, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *DecodeScriptCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *DecodeScriptCmd) Method() string { + return "decodescript" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *DecodeScriptCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "decodescript", + Id: cmd.id, + Params: []interface{}{ + cmd.HexScript, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *DecodeScriptCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + hexscript, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter hexscript must be an array of objects") + } + + newCmd, err := NewDecodeScriptCmd(r.Id, hexscript) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// DumpPrivKeyCmd is a type handling custom marshaling and +// unmarshaling of dumpprivkey JSON RPC commands. +type DumpPrivKeyCmd struct { + id interface{} + Address string +} + +// Enforce that DumpPrivKeyCmd satisifies the Cmd interface. +var _ Cmd = &DumpPrivKeyCmd{} + +// NewDumpPrivKeyCmd creates a new DumpPrivkeyCmd. +func NewDumpPrivKeyCmd(id interface{}, address string) (*DumpPrivKeyCmd, error) { + return &DumpPrivKeyCmd{ + id: id, + Address: address, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *DumpPrivKeyCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *DumpPrivKeyCmd) Method() string { + return "dumpprivkey" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *DumpPrivKeyCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "dumpprivkey", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *DumpPrivKeyCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be an array of objects") + } + + newCmd, err := NewDumpPrivKeyCmd(r.Id, address) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// DumpWalletCmd is a type handling custom marshaling and +// unmarshaling of dumpwallet JSON RPC commands. +type DumpWalletCmd struct { + id interface{} + Filename string +} + +// Enforce that DumpWalletCmd satisifies the Cmd interface. +var _ Cmd = &DumpWalletCmd{} + +// NewDumpWalletCmd creates a new DumpPrivkeyCmd. +func NewDumpWalletCmd(id interface{}, filename string) (*DumpWalletCmd, error) { + return &DumpWalletCmd{ + id: id, + Filename: filename, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *DumpWalletCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *DumpWalletCmd) Method() string { + return "dumpwallet" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *DumpWalletCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "dumpwallet", + Id: cmd.id, + Params: []interface{}{ + cmd.Filename, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *DumpWalletCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + filename, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter filename must be an array of objects") + } + + newCmd, err := NewDumpWalletCmd(r.Id, filename) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// EncryptWalletCmd is a type handling custom marshaling and +// unmarshaling of ecryptwallet JSON RPC commands. +type EncryptWalletCmd struct { + id interface{} + Passphrase string +} + +// Enforce that EncryptWalletCmd satisifies the Cmd interface. +var _ Cmd = &EncryptWalletCmd{} + +// NewEncryptWalletCmd creates a new EncryptWalletCmd. +func NewEncryptWalletCmd(id interface{}, passphrase string) (*EncryptWalletCmd, error) { + return &EncryptWalletCmd{ + id: id, + Passphrase: passphrase, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *EncryptWalletCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *EncryptWalletCmd) Method() string { + return "encryptwallet" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *EncryptWalletCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "encryptwallet", + Id: cmd.id, + Params: []interface{}{ + cmd.Passphrase, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *EncryptWalletCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + passphrase, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter passphrase must be a string") + } + + newCmd, err := NewEncryptWalletCmd(r.Id, passphrase) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetAccountCmd is a type handling custom marshaling and +// unmarshaling of getaccount JSON RPC commands. +type GetAccountCmd struct { + id interface{} + Address string +} + +// Enforce that GetAccountCmd satisifies the Cmd interface. +var _ Cmd = &GetAccountCmd{} + +// NewGetAccountCmd creates a new GetAccountCmd. +func NewGetAccountCmd(id interface{}, address string) (*GetAccountCmd, error) { + return &GetAccountCmd{ + id: id, + Address: address, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetAccountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetAccountCmd) Method() string { + return "getaccount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetAccountCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getaccount", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetAccountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be a string") + } + + newCmd, err := NewGetAccountCmd(r.Id, address) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetAccountAddressCmd is a type handling custom marshaling and +// unmarshaling of getaccountaddress JSON RPC commands. +type GetAccountAddressCmd struct { + id interface{} + Account string +} + +// Enforce that GetAccountAddressCmd satisifies the Cmd interface. +var _ Cmd = &GetAccountAddressCmd{} + +// NewGetAccountAddressCmd creates a new GetAccountAddressCmd. +func NewGetAccountAddressCmd(id interface{}, account string) (*GetAccountAddressCmd, error) { + return &GetAccountAddressCmd{ + id: id, + Account: account, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetAccountAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetAccountAddressCmd) Method() string { + return "getaccountaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetAccountAddressCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "accountaddress", + Id: cmd.id, + Params: []interface{}{ + cmd.Account, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetAccountAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter account must be a string") + } + + newCmd, err := NewGetAccountAddressCmd(r.Id, account) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetAddedNodeInfoCmd is a type handling custom marshaling and +// unmarshaling of getaddednodeinfo JSON RPC commands. +type GetAddedNodeInfoCmd struct { + id interface{} + Dns bool + Node string +} + +// Enforce that GetAddedNodeInfoCmd satisifies the Cmd interface. +var _ Cmd = &GetAddedNodeInfoCmd{} + +// NewGetAddedNodeInfoCmd creates a new GetAddedNodeInfoCmd. Optionally the +// node to be queried may be provided. More than one optonal argument is an +// error. +func NewGetAddedNodeInfoCmd(id interface{}, dns bool, optArgs ...string) (*GetAddedNodeInfoCmd, error) { + var node string + + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + node = optArgs[1] + } + return &GetAddedNodeInfoCmd{ + id: id, + Dns: dns, + Node: node, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetAddedNodeInfoCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetAddedNodeInfoCmd) Method() string { + return "getaddednodeinfo" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetAddedNodeInfoCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + var raw RawCmd + if cmd.Node == "" { + raw = RawCmd{ + Jsonrpc: "1.0", + Method: "getaddednodeinfo", + Id: cmd.id, + Params: []interface{}{ + cmd.Dns, + }, + } + } else { + raw = RawCmd{ + Jsonrpc: "1.0", + Method: "getaddednodeinfo", + Id: cmd.id, + Params: []interface{}{ + cmd.Dns, + cmd.Node, + }, + } + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetAddedNodeInfoCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) < 1 || len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + dns, ok := r.Params[0].(bool) + if !ok { + return errors.New("first parameter dns must be a bool") + } + + var node string + if len(r.Params) == 2 { + node, ok = r.Params[1].(string) + if !ok { + return errors.New("second parameter node must be a string") + } + + } + + newCmd, err := NewGetAddedNodeInfoCmd(r.Id, dns, node) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetAddressesByAccountCmd is a type handling custom marshaling and +// unmarshaling of getaddressesbyaccount JSON RPC commands. +type GetAddressesByAccountCmd struct { + id interface{} + Account string +} + +// Enforce that GetAddressesByAccountCmd satisifies the Cmd interface. +var _ Cmd = &GetAddressesByAccountCmd{} + +// NewGetAddressesByAccountCmd creates a new GetAddressesByAccountCmd. +func NewGetAddressesByAccountCmd(id interface{}, account string) (*GetAddressesByAccountCmd, error) { + return &GetAddressesByAccountCmd{ + id: id, + Account: account, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetAddressesByAccountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetAddressesByAccountCmd) Method() string { + return "getaddressesbyaccount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetAddressesByAccountCmd) MarshalJSON() ([]byte, error) { + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getaddressesbyaccount", + Id: cmd.id, + Params: []interface{}{ + cmd.Account, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetAddressesByAccountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter account must be a string") + } + + newCmd, err := NewGetAddressesByAccountCmd(r.Id, account) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetBalanceCmd is a type handling custom marshaling and +// unmarshaling of getbalance JSON RPC commands. +type GetBalanceCmd struct { + id interface{} + Account string + Minconf int +} + +// Enforce that GetBalanceCmd satisifies the Cmd interface. +var _ Cmd = &GetBalanceCmd{} + +// NewGetBalanceCmd creates a new GetBalanceCmd. Optionally a string for account +// and an int for minconf may be provided as arguments. +func NewGetBalanceCmd(id interface{}, optArgs ...interface{}) (*GetBalanceCmd, error) { + var account string + var minconf int = 1 + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + a, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument account is not a string") + } + account = a + } + + if len(optArgs) > 1 { + m, ok := optArgs[1].(int) + if !ok { + return nil, errors.New("second optional argument minconf is not a int") + } + minconf = m + } + + return &GetBalanceCmd{ + id: id, + Account: account, + Minconf: minconf, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBalanceCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBalanceCmd) Method() string { + return "getbalance" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBalanceCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getbalance", + Id: cmd.id, + Params: []interface{}{ + cmd.Account, + }, + } + + if cmd.Account != "" || cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Account) + } + if cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Minconf) + } + + // Fill and marshal a RawCmd. + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBalanceCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter account must be a string") + } + optArgs = append(optArgs, account) + } + + if len(r.Params) > 1 { + minconf, ok := r.Params[1].(float64) + if !ok { + return errors.New("first optional parameter minconf must be a number") + } + optArgs = append(optArgs, int(minconf)) + } + + newCmd, err := NewGetBalanceCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetBestBlockHashCmd is a type handling custom marshaling and +// unmarshaling of getbestblockhash JSON RPC commands. +type GetBestBlockHashCmd struct { + id interface{} +} + +// Enforce that GetBestBlockHashCmd satisifies the Cmd interface. +var _ Cmd = &GetBestBlockHashCmd{} + +// NewGetBestBlockHashCmd creates a new GetBestBlockHashCmd. +func NewGetBestBlockHashCmd(id interface{}) (*GetBestBlockHashCmd, error) { + return &GetBestBlockHashCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBestBlockHashCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBestBlockHashCmd) Method() string { + return "getbestblockhash" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBestBlockHashCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getbestblockhash", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBestBlockHashCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetBestBlockHashCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetBlockCmd is a type handling custom marshaling and +// unmarshaling of getblock JSON RPC commands. +type GetBlockCmd struct { + id interface{} + Hash string +} + +// Enforce that GetBlockCmd satisifies the Cmd interface. +var _ Cmd = &GetBlockCmd{} + +// NewGetBlockCmd creates a new GetBlockCmd. +func NewGetBlockCmd(id interface{}, hash string) (*GetBlockCmd, error) { + return &GetBlockCmd{ + id: id, + Hash: hash, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBlockCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBlockCmd) Method() string { + return "getblock" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBlockCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getblock", + Id: cmd.id, + Params: []interface{}{ + cmd.Hash, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBlockCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + hash, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter hash must be a string") + } + + newCmd, err := NewGetBlockCmd(r.Id, hash) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetBlockCountCmd is a type handling custom marshaling and +// unmarshaling of getblockcount JSON RPC commands. +type GetBlockCountCmd struct { + id interface{} +} + +// Enforce that GetBlockCountCmd satisifies the Cmd interface. +var _ Cmd = &GetBlockCountCmd{} + +// NewGetBlockCountCmd creates a new GetBlockCountCmd. +func NewGetBlockCountCmd(id interface{}) (*GetBlockCountCmd, error) { + return &GetBlockCountCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBlockCountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBlockCountCmd) Method() string { + return "getblockcount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBlockCountCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getblockcount", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBlockCountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetBlockCountCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetBlockHashCmd is a type handling custom marshaling and +// unmarshaling of getblockhash JSON RPC commands. +type GetBlockHashCmd struct { + id interface{} + Index int64 +} + +// Enforce that GetBlockHashCmd satisifies the Cmd interface. +var _ Cmd = &GetBlockHashCmd{} + +// NewGetBlockHashCmd creates a new GetBlockHashCmd. +func NewGetBlockHashCmd(id interface{}, index int64) (*GetBlockHashCmd, error) { + return &GetBlockHashCmd{ + id: id, + Index: index, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBlockHashCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBlockHashCmd) Method() string { + return "getblockhash" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBlockHashCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getblockhash", + Id: cmd.id, + Params: []interface{}{ + cmd.Index, + }, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBlockHashCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + hash, ok := r.Params[0].(float64) + if !ok { + return errors.New("first parameter hash must be a number") + } + + newCmd, err := NewGetBlockHashCmd(r.Id, int64(hash)) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// TemplateRequest is a request object as defined in BIP22 +// (https://en.bitcoin.it/wiki/BIP_0022), it is optionally provided as an +// pointer argument to GetBlockTemplateCmd. +type TemplateRequest struct { + Mode string `json:"mode,omitempty"` + Capabilities []string `json:"capabilities"` +} + +// GetBlockTemplateCmd is a type handling custom marshaling and +// unmarshaling of getblocktemplate JSON RPC commands. +type GetBlockTemplateCmd struct { + id interface{} + Request *TemplateRequest +} + +// Enforce that GetBlockTemplateCmd satisifies the Cmd interface. +var _ Cmd = &GetBlockTemplateCmd{} + +// NewGetBlockTemplateCmd creates a new GetBlockTemplateCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewGetBlockTemplateCmd(id interface{}, optArgs ...*TemplateRequest) (*GetBlockTemplateCmd, error) { + var request *TemplateRequest + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + request = optArgs[0] + } + return &GetBlockTemplateCmd{ + id: id, + Request: request, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetBlockTemplateCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetBlockTemplateCmd) Method() string { + return "getblocktemplate" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetBlockTemplateCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getblocktemplate", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Request != nil { + raw.Params = append(raw.Params, cmd.Request) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetBlockTemplateCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 1 { + return ErrWrongNumberOfParams + } + optArgs := make([]*TemplateRequest, 0, 1) + if len(r.Params) > 0 { + rmap, ok := r.Params[0].(map[string]interface{}) + if !ok { + return errors.New("first optional parameter template request must be an object") + } + + trequest := new(TemplateRequest) + // optional mode string. + mode, ok := rmap["mode"] + if ok { + smode, ok := mode.(string) + if !ok { + return errors.New("TemplateRequest mode must be a string") + } + trequest.Mode = smode + } + + capabilities, ok := rmap["capabilities"] + if ok { + scap, ok := capabilities.([]string) + if !ok { + return errors.New("TemplateRequest mode must be a string array") + } + trequest.Capabilities = scap + } + + optArgs = append(optArgs, trequest) + } + + newCmd, err := NewGetBlockTemplateCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetConnectionCountCmd is a type handling custom marshaling and +// unmarshaling of getconnectioncount JSON RPC commands. +type GetConnectionCountCmd struct { + id interface{} +} + +// Enforce that GetConnectionCountCmd satisifies the Cmd interface. +var _ Cmd = &GetConnectionCountCmd{} + +// NewGetConnectionCountCmd creates a new GetConnectionCountCmd. +func NewGetConnectionCountCmd(id interface{}) (*GetConnectionCountCmd, error) { + return &GetConnectionCountCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetConnectionCountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetConnectionCountCmd) Method() string { + return "getconnectioncount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetConnectionCountCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getconnectioncount", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetConnectionCountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetConnectionCountCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetDifficultyCmd is a type handling custom marshaling and +// unmarshaling of getdifficulty JSON RPC commands. +type GetDifficultyCmd struct { + id interface{} +} + +// Enforce that GetDifficultyCmd satisifies the Cmd interface. +var _ Cmd = &GetDifficultyCmd{} + +// NewGetDifficultyCmd creates a new GetDifficultyCmd. +func NewGetDifficultyCmd(id interface{}) (*GetDifficultyCmd, error) { + return &GetDifficultyCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetDifficultyCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetDifficultyCmd) Method() string { + return "getdifficulty" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetDifficultyCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getdifficulty", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetDifficultyCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetDifficultyCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetGenerateCmd is a type handling custom marshaling and +// unmarshaling of getgenerate JSON RPC commands. +type GetGenerateCmd struct { + id interface{} +} + +// Enforce that GetGenerateCmd satisifies the Cmd interface. +var _ Cmd = &GetGenerateCmd{} + +// NewGetGenerateCmd creates a new GetGenerateCmd. +func NewGetGenerateCmd(id interface{}) (*GetGenerateCmd, error) { + return &GetGenerateCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetGenerateCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetGenerateCmd) Method() string { + return "getgenerate" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetGenerateCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getgenerate", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetGenerateCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetGenerateCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetHashesPerSecCmd is a type handling custom marshaling and +// unmarshaling of gethashespersec JSON RPC commands. +type GetHashesPerSecCmd struct { + id interface{} +} + +// Enforce that GetHashesPerSecCmd satisifies the Cmd interface. +var _ Cmd = &GetHashesPerSecCmd{} + +// NewGetHashesPerSecCmd creates a new GetHashesPerSecCmd. +func NewGetHashesPerSecCmd(id interface{}) (*GetHashesPerSecCmd, error) { + return &GetHashesPerSecCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetHashesPerSecCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetHashesPerSecCmd) Method() string { + return "gethashespersec" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetHashesPerSecCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "gethashespersec", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetHashesPerSecCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetHashesPerSecCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetInfoCmd is a type handling custom marshaling and +// unmarshaling of getinfo JSON RPC commands. +type GetInfoCmd struct { + id interface{} +} + +// Enforce that GetInfoCmd satisifies the Cmd interface. +var _ Cmd = &GetInfoCmd{} + +// NewGetInfoCmd creates a new GetInfoCmd. +func NewGetInfoCmd(id interface{}) (*GetInfoCmd, error) { + return &GetInfoCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetInfoCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetInfoCmd) Method() string { + return "getinfo" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetInfoCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getinfo", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetInfoCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetInfoCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetNetTotalsCmd is a type handling custom marshaling and +// unmarshaling of getnettotals JSON RPC commands. +type GetNetTotalsCmd struct { + id interface{} +} + +// Enforce that GetNetTotalsCmd satisifies the Cmd interface. +var _ Cmd = &GetNetTotalsCmd{} + +// NewGetNetTotalsCmd creates a new GetNetTotalsCmd. +func NewGetNetTotalsCmd(id interface{}) (*GetNetTotalsCmd, error) { + return &GetNetTotalsCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetNetTotalsCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetNetTotalsCmd) Method() string { + return "getnettotals" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetNetTotalsCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getnettotals", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetNetTotalsCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetNetTotalsCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetNetworkHashPSCmd is a type handling custom marshaling and +// unmarshaling of getnetworkhashps JSON RPC commands. +type GetNetworkHashPSCmd struct { + id interface{} + Blocks int + Height int +} + +// Enforce that GetNetworkHashPSCmd satisifies the Cmd interface. +var _ Cmd = &GetNetworkHashPSCmd{} + +// NewGetNetworkHashPSCmd creates a new GetNetworkHashPSCmd. +func NewGetNetworkHashPSCmd(id interface{}, optArgs ...int) (*GetNetworkHashPSCmd, error) { + blocks := 120 + height := -1 + + if len(optArgs) > 0 { + if len(optArgs) > 2 { + return nil, ErrTooManyOptArgs + } + + blocks = optArgs[0] + + if len(optArgs) > 1 { + height = optArgs[1] + } + } + return &GetNetworkHashPSCmd{ + id: id, + Blocks: blocks, + Height: height, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetNetworkHashPSCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetNetworkHashPSCmd) Method() string { + return "getnetworkhashps" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetNetworkHashPSCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getnetworkhashps", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Blocks != 120 || cmd.Height != -1 { + raw.Params = append(raw.Params, cmd.Blocks) + } + + if cmd.Height != -1 { + raw.Params = append(raw.Params, cmd.Height) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetNetworkHashPSCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]int, 0, 2) + if len(r.Params) > 0 { + blocks, ok := r.Params[0].(float64) + if !ok { + return errors.New("first optional parameter blocks must be a number") + } + + optArgs = append(optArgs, int(blocks)) + } + + if len(r.Params) > 1 { + height, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter height must be a number") + } + + optArgs = append(optArgs, int(height)) + } + newCmd, err := NewGetNetworkHashPSCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetMiningInfoCmd is a type handling custom marshaling and +// unmarshaling of getmininginfo JSON RPC commands. +type GetMiningInfoCmd struct { + id interface{} +} + +// Enforce that GetMiningInfoCmd satisifies the Cmd interface. +var _ Cmd = &GetMiningInfoCmd{} + +// NewGetMiningInfoCmd creates a new GetMiningInfoCmd. +func NewGetMiningInfoCmd(id interface{}) (*GetMiningInfoCmd, error) { + return &GetMiningInfoCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetMiningInfoCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetMiningInfoCmd) Method() string { + return "getmininginfo" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetMiningInfoCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getmininginfo", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetMiningInfoCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetMiningInfoCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetNewAddressCmd is a type handling custom marshaling and +// unmarshaling of getnewaddress JSON RPC commands. +type GetNewAddressCmd struct { + id interface{} + Address string +} + +// Enforce that GetNewAddressCmd satisifies the Cmd interface. +var _ Cmd = &GetNewAddressCmd{} + +// NewGetNewAddressCmd creates a new GetNewAddressCmd. +func NewGetNewAddressCmd(id interface{}, optArgs ...string) (*GetNewAddressCmd, error) { + var address string + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + address = optArgs[0] + + } + return &GetNewAddressCmd{ + id: id, + Address: address, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetNewAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetNewAddressCmd) Method() string { + return "getnewaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetNewAddressCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getnewaddress", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Address != "" { + raw.Params = append(raw.Params, cmd.Address) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetNewAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 1 { + return ErrWrongNumberOfParams + } + + optArgs := make([]string, 0, 1) + if len(r.Params) > 0 { + addr, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter address must be a string") + } + + optArgs = append(optArgs, addr) + } + + newCmd, err := NewGetNewAddressCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetPeerInfoCmd is a type handling custom marshaling and +// unmarshaling of getpeerinfo JSON RPC commands. +type GetPeerInfoCmd struct { + id interface{} +} + +// Enforce that GetPeerInfoCmd satisifies the Cmd interface. +var _ Cmd = &GetPeerInfoCmd{} + +// NewGetPeerInfoCmd creates a new GetPeerInfoCmd. +func NewGetPeerInfoCmd(id interface{}) (*GetPeerInfoCmd, error) { + return &GetPeerInfoCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetPeerInfoCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetPeerInfoCmd) Method() string { + return "getpeerinfo" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetPeerInfoCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getpeerinfo", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetPeerInfoCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetPeerInfoCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetRawChangeAddressCmd is a type handling custom marshaling and +// unmarshaling of getrawchangeaddress JSON RPC commands. +type GetRawChangeAddressCmd struct { + id interface{} + Account string +} + +// Enforce that GetRawChangeAddressCmd satisifies the Cmd interface. +var _ Cmd = &GetRawChangeAddressCmd{} + +// NewGetRawChangeAddressCmd creates a new GetRawChangeAddressCmd. +func NewGetRawChangeAddressCmd(id interface{}, optArgs ...string) (*GetRawChangeAddressCmd, error) { + var account string + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + account = optArgs[0] + + } + return &GetRawChangeAddressCmd{ + id: id, + Account: account, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetRawChangeAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetRawChangeAddressCmd) Method() string { + return "getrawchangeaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetRawChangeAddressCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getrawchangeaddress", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Account != "" { + raw.Params = append(raw.Params, cmd.Account) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetRawChangeAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 1 { + return ErrWrongNumberOfParams + } + + optArgs := make([]string, 0, 1) + if len(r.Params) > 0 { + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter account must be a string") + } + + optArgs = append(optArgs, account) + } + + newCmd, err := NewGetRawChangeAddressCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetRawMempoolCmd is a type handling custom marshaling and +// unmarshaling of getrawmempool JSON RPC commands. +type GetRawMempoolCmd struct { + id interface{} +} + +// Enforce that GetRawMempoolCmd satisifies the Cmd interface. +var _ Cmd = &GetRawMempoolCmd{} + +// NewGetRawMempoolCmd creates a new GetRawMempoolCmd. +func NewGetRawMempoolCmd(id interface{}) (*GetRawMempoolCmd, error) { + return &GetRawMempoolCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetRawMempoolCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetRawMempoolCmd) Method() string { + return "getrawmempool" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetRawMempoolCmd) MarshalJSON() ([]byte, error) { + + // Fill and marshal a RawCmd. + return json.Marshal(RawCmd{ + Jsonrpc: "1.0", + Method: "getrawmempool", + Id: cmd.id, + Params: []interface{}{}, + }) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetRawMempoolCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetRawMempoolCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetRawTransactionCmd is a type handling custom marshaling and +// unmarshaling of getrawtransaction JSON RPC commands. +type GetRawTransactionCmd struct { + id interface{} + Txid string + Verbose bool +} + +// Enforce that GetRawTransactionCmd satisifies the Cmd interface. +var _ Cmd = &GetRawTransactionCmd{} + +// NewGetRawTransactionCmd creates a new GetRawTransactionCmd. +func NewGetRawTransactionCmd(id interface{}, txid string, optArgs ...bool) (*GetRawTransactionCmd, error) { + var verbose bool + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + verbose = optArgs[0] + + } + return &GetRawTransactionCmd{ + id: id, + Txid: txid, + Verbose: verbose, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetRawTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetRawTransactionCmd) Method() string { + return "getrawtransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetRawTransactionCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getrawtransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.Txid, + }, + } + + if cmd.Verbose { + raw.Params = append(raw.Params, cmd.Verbose) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetRawTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 || len(r.Params) < 1 { + return ErrWrongNumberOfParams + } + + txid, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter txid must be a string") + } + + optArgs := make([]bool, 0, 1) + if len(r.Params) == 2 { + verbose, ok := r.Params[1].(bool) + if !ok { + return errors.New("second optional parameter verbose must be a bool") + } + + optArgs = append(optArgs, verbose) + } + + newCmd, err := NewGetRawTransactionCmd(r.Id, txid, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetReceivedByAccountCmd is a type handling custom marshaling and +// unmarshaling of getreceivedbyaccount JSON RPC commands. +type GetReceivedByAccountCmd struct { + id interface{} + Account string + Minconf int +} + +// Enforce that GetReceivedByAccountCmd satisifies the Cmd interface. +var _ Cmd = &GetReceivedByAccountCmd{} + +// NewGetReceivedByAccountCmd creates a new GetReceivedByAccountCmd. +func NewGetReceivedByAccountCmd(id interface{}, optArgs ...interface{}) (*GetReceivedByAccountCmd, error) { + if len(optArgs) > 2 { + return nil, ErrTooManyOptArgs + } + var account string + if len(optArgs) > 0 { + a, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument account is not a string") + } + + account = a + } + var minconf int = 1 + if len(optArgs) > 1 { + m, ok := optArgs[1].(int) + if !ok { + return nil, errors.New("second optional argument minconf is not a int") + } + minconf = m + + } + return &GetReceivedByAccountCmd{ + id: id, + Account: account, + Minconf: minconf, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetReceivedByAccountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetReceivedByAccountCmd) Method() string { + return "getreceivedbyaccount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetReceivedByAccountCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getreceivedbyaccount", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Account != "" || cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Account) + } + + if cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Minconf) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetReceivedByAccountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter account must be a string") + } + + optArgs = append(optArgs, account) + } + + if len(r.Params) > 1 { + minconf, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter verbose must be a number") + } + + optArgs = append(optArgs, int(minconf)) + } + + newCmd, err := NewGetReceivedByAccountCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetReceivedByAddressCmd is a type handling custom marshaling and +// unmarshaling of getrecievedbyaddress JSON RPC commands. +type GetReceivedByAddressCmd struct { + id interface{} + Address string + Minconf int +} + +// Enforce that GetReceivedByAddressCmd satisifies the Cmd interface. +var _ Cmd = &GetReceivedByAddressCmd{} + +// NewGetReceivedByAddressCmd creates a new GetReceivedByAddressCmd. +func NewGetReceivedByAddressCmd(id interface{}, optArgs ...interface{}) (*GetReceivedByAddressCmd, error) { + if len(optArgs) > 2 { + return nil, ErrTooManyOptArgs + } + var address string + if len(optArgs) > 0 { + a, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument address is not a string") + } + + address = a + } + var minconf int = 1 + if len(optArgs) > 1 { + m, ok := optArgs[1].(int) + if !ok { + return nil, errors.New("second optional argument minconf is not a int") + } + minconf = m + + } + return &GetReceivedByAddressCmd{ + id: id, + Address: address, + Minconf: minconf, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetReceivedByAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetReceivedByAddressCmd) Method() string { + return "getrecievedbyaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetReceivedByAddressCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getrecievedbyaddress", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Address != "" || cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Address) + } + + if cmd.Minconf != 1 { + raw.Params = append(raw.Params, cmd.Minconf) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetReceivedByAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter address must be a string") + } + + optArgs = append(optArgs, address) + } + + if len(r.Params) > 1 { + minconf, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter verbose must be a number") + } + + optArgs = append(optArgs, int(minconf)) + } + + newCmd, err := NewGetReceivedByAddressCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetTransactionCmd is a type handling custom marshaling and +// unmarshaling of gettransaction JSON RPC commands. +type GetTransactionCmd struct { + id interface{} + Txid string +} + +// Enforce that GetTransactionCmd satisifies the Cmd interface. +var _ Cmd = &GetTransactionCmd{} + +// NewGetTransactionCmd creates a new GetTransactionCmd. +func NewGetTransactionCmd(id interface{}, txid string) (*GetTransactionCmd, error) { + return &GetTransactionCmd{ + id: id, + Txid: txid, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetTransactionCmd) Method() string { + return "gettransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetTransactionCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "gettransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.Txid, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + txid, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter txid must be a string") + } + + newCmd, err := NewGetTransactionCmd(r.Id, txid) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetTxOutCmd is a type handling custom marshaling and +// unmarshaling of gettxout JSON RPC commands. +type GetTxOutCmd struct { + id interface{} + Txid string + Output int + IncludeMempool bool +} + +// Enforce that GetTxOutCmd satisifies the Cmd interface. +var _ Cmd = &GetTxOutCmd{} + +// NewGetTxOutCmd creates a new GetTxOutCmd. +func NewGetTxOutCmd(id interface{}, txid string, output int, optArgs ...bool) (*GetTxOutCmd, error) { + var mempool bool + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + mempool = optArgs[0] + } + return &GetTxOutCmd{ + id: id, + Txid: txid, + Output: output, + IncludeMempool: mempool, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetTxOutCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetTxOutCmd) Method() string { + return "gettxout" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetTxOutCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "gettxout", + Id: cmd.id, + Params: []interface{}{ + cmd.Txid, + cmd.Output, + }, + } + + if cmd.IncludeMempool != false { + raw.Params = append(raw.Params, cmd.IncludeMempool) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetTxOutCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 3 || len(r.Params) < 2 { + return ErrWrongNumberOfParams + } + + txid, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter txid must be a string") + } + + output, ok := r.Params[1].(float64) + if !ok { + return errors.New("first parameter output must be a number") + } + + optArgs := make([]bool, 0, 1) + if len(r.Params) == 2 { + mempool, ok := r.Params[2].(bool) + if !ok { + return errors.New("third optional parameter includemempool must be a bool") + } + + optArgs = append(optArgs, mempool) + } + + newCmd, err := NewGetTxOutCmd(r.Id, txid, int(output), optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// GetTxOutSetInfoCmd is a type handling custom marshaling and +// unmarshaling of gettxoutsetinfo JSON RPC commands. +type GetTxOutSetInfoCmd struct { + id interface{} +} + +// Enforce that GetTxOutSetInfoCmd satisifies the Cmd interface. +var _ Cmd = &GetTxOutSetInfoCmd{} + +// NewGetTxOutSetInfoCmd creates a new GetTxOutSetInfoCmd. +func NewGetTxOutSetInfoCmd(id interface{}) (*GetTxOutSetInfoCmd, error) { + return &GetTxOutSetInfoCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetTxOutSetInfoCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetTxOutSetInfoCmd) Method() string { + return "gettxoutsetinfo" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetTxOutSetInfoCmd) MarshalJSON() ([]byte, error) { + + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "gettxoutsetinfo", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetTxOutSetInfoCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewGetTxOutSetInfoCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// WorkRequest is a request object as defined in +// https://en.bitcoin.it/wiki/Getwork, it is provided as a +// pointer argument to GetWorkCmd. +type WorkRequest struct { + Data string `json:"data"` + Target string `json:"target"` + Algorithm string `json:"algorithm,omitempty"` +} + +// GetWorkCmd is a type handling custom marshaling and +// unmarshaling of getwork JSON RPC commands. +type GetWorkCmd struct { + id interface{} + Request WorkRequest +} + +// Enforce that GetWorkCmd satisifies the Cmd interface. +var _ Cmd = &GetWorkCmd{} + +// NewGetWorkCmd creates a new GetWorkCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewGetWorkCmd(id interface{}, request WorkRequest) (*GetWorkCmd, error) { + return &GetWorkCmd{ + id: id, + Request: request, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *GetWorkCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *GetWorkCmd) Method() string { + return "getwork" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *GetWorkCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "getwork", + Id: cmd.id, + Params: []interface{}{ + cmd.Request, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *GetWorkCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + rmap, ok := r.Params[0].(map[string]interface{}) + if !ok { + return errors.New("first optional parameter template request must be an object") + } + + wrequest := new(WorkRequest) + // data is required + data, ok := rmap["data"] + if !ok { + return errors.New("WorkRequest data must be present") + } + sdata, ok := data.(string) + if !ok { + return errors.New("WorkRequest data must be a string") + } + wrequest.Data = sdata + + // target is required + target, ok := rmap["target"] + if !ok { + return errors.New("WorkRequest target must be present") + } + starget, ok := target.(string) + if !ok { + return errors.New("WorkRequest target must be a string") + } + wrequest.Target = starget + + // algorithm is optional + algo, ok := rmap["algorithm"] + if ok { + salgo, ok := algo.(string) + if !ok { + return errors.New("WorkRequest algorithm must be a string") + } + wrequest.Algorithm = salgo + } + + newCmd, err := NewGetWorkCmd(r.Id, *wrequest) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// HelpCmd is a type handling custom marshaling and +// unmarshaling of help JSON RPC commands. +type HelpCmd struct { + id interface{} + Command string +} + +// Enforce that HelpCmd satisifies the Cmd interface. +var _ Cmd = &HelpCmd{} + +// NewHelpCmd creates a new HelpCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewHelpCmd(id interface{}, optArgs ...string) (*HelpCmd, error) { + + var command string + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + command = optArgs[0] + } + return &HelpCmd{ + id: id, + Command: command, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *HelpCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *HelpCmd) Method() string { + return "help" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *HelpCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "help", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Command != "" { + raw.Params = append(raw.Params, cmd.Command) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *HelpCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 1 { + return ErrWrongNumberOfParams + } + + optArgs := make([]string, 0, 1) + if len(r.Params) == 1 { + command, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter command must be a string") + } + + optArgs = append(optArgs, command) + } + + newCmd, err := NewHelpCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ImportPrivKeyCmd is a type handling custom marshaling and +// unmarshaling of importprivkey JSON RPC commands. +type ImportPrivKeyCmd struct { + id interface{} + PrivKey string + Label string + ReScan bool +} + +// Enforce that ImportPrivKeyCmd satisifies the Cmd interface. +var _ Cmd = &ImportPrivKeyCmd{} + +// NewImportPrivKeyCmd creates a new ImportPrivKeyCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewImportPrivKeyCmd(id interface{}, privkey string, optArgs ...interface{}) (*ImportPrivKeyCmd, error) { + var label string + var rescan bool + var ok bool + + if len(optArgs) > 2 { + return nil, ErrTooManyOptArgs + } + if len(optArgs) > 0 { + label, ok = optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument label is not a string") + } + } + if len(optArgs) > 1 { + rescan, ok = optArgs[1].(bool) + if !ok { + return nil, errors.New("first optional argument rescan is not a bool") + } + } + return &ImportPrivKeyCmd{ + id: id, + PrivKey: privkey, + Label: label, + ReScan: rescan, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ImportPrivKeyCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ImportPrivKeyCmd) Method() string { + return "importprivkey" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ImportPrivKeyCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "importprivkey", + Id: cmd.id, + Params: []interface{}{ + cmd.PrivKey, + }, + } + + if cmd.Label != "" || cmd.ReScan { + raw.Params = append(raw.Params, cmd.Label) + } + + if cmd.ReScan { + raw.Params = append(raw.Params, cmd.ReScan) + } + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ImportPrivKeyCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 3 { + return ErrWrongNumberOfParams + } + + privkey, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter privkey must be a string") + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 1 { + label, ok := r.Params[1].(string) + if !ok { + return errors.New("second optional parameter label must be a string") + } + + optArgs = append(optArgs, label) + } + + if len(r.Params) > 2 { + rescan, ok := r.Params[2].(bool) + if !ok { + return errors.New("third optional parameter rescan must be a bool") + } + + optArgs = append(optArgs, rescan) + } + + newCmd, err := NewImportPrivKeyCmd(r.Id, privkey, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ImportWalletCmd is a type handling custom marshaling and +// unmarshaling of importwallet JSON RPC commands. +type ImportWalletCmd struct { + id interface{} + Filename string +} + +// Enforce that ImportWalletCmd satisifies the Cmd interface. +var _ Cmd = &ImportWalletCmd{} + +// NewImportWalletCmd creates a new ImportWalletCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewImportWalletCmd(id interface{}, filename string) (*ImportWalletCmd, error) { + return &ImportWalletCmd{ + id: id, + Filename: filename, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ImportWalletCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ImportWalletCmd) Method() string { + return "importwallet" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ImportWalletCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "importwallet", + Id: cmd.id, + Params: []interface{}{ + cmd.Filename, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ImportWalletCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + filename, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter filename must be a string") + } + + newCmd, err := NewImportWalletCmd(r.Id, filename) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// KeyPoolRefillCmd is a type handling custom marshaling and +// unmarshaling of keypoolrefill JSON RPC commands. +type KeyPoolRefillCmd struct { + id interface{} +} + +// Enforce that KeyPoolRefillCmd satisifies the Cmd interface. +var _ Cmd = &KeyPoolRefillCmd{} + +// NewKeyPoolRefillCmd creates a new KeyPoolRefillCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewKeyPoolRefillCmd(id interface{}) (*KeyPoolRefillCmd, error) { + return &KeyPoolRefillCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *KeyPoolRefillCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *KeyPoolRefillCmd) Method() string { + return "keypoolrefill" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *KeyPoolRefillCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "keypoolrefill", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *KeyPoolRefillCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewKeyPoolRefillCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListAccountsCmd is a type handling custom marshaling and +// unmarshaling of listaccounts JSON RPC commands. +type ListAccountsCmd struct { + id interface{} + MinConf int +} + +// Enforce that ListAccountsCmd satisifies the Cmd interface. +var _ Cmd = &ListAccountsCmd{} + +// NewListAccountsCmd creates a new ListAccountsCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListAccountsCmd(id interface{}, optArgs ...int) (*ListAccountsCmd, error) { + var minconf = 1 + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + minconf = optArgs[0] + } + return &ListAccountsCmd{ + id: id, + MinConf: minconf, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListAccountsCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListAccountsCmd) Method() string { + return "listaccounts" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListAccountsCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listaccounts", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.MinConf != 1 { + raw.Params = append(raw.Params, cmd.MinConf) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListAccountsCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 1 { + return ErrWrongNumberOfParams + } + + optArgs := make([]int, 0, 1) + if len(r.Params) == 1 { + minconf, ok := r.Params[0].(float64) + if !ok { + return errors.New("first parameter minconf must be a number") + } + optArgs = append(optArgs, int(minconf)) + } + + newCmd, err := NewListAccountsCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListAddressGroupingsCmd is a type handling custom marshaling and +// unmarshaling of listaddressgroupings JSON RPC commands. +type ListAddressGroupingsCmd struct { + id interface{} +} + +// Enforce that ListAddressGroupingsCmd satisifies the Cmd interface. +var _ Cmd = &ListAddressGroupingsCmd{} + +// NewListAddressGroupingsCmd creates a new ListAddressGroupingsCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListAddressGroupingsCmd(id interface{}) (*ListAddressGroupingsCmd, error) { + return &ListAddressGroupingsCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListAddressGroupingsCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListAddressGroupingsCmd) Method() string { + return "listaddressgroupings" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListAddressGroupingsCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listaddressgroupings", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListAddressGroupingsCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewListAddressGroupingsCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListLockUnspentCmd is a type handling custom marshaling and +// unmarshaling of listlockunspent JSON RPC commands. +type ListLockUnspentCmd struct { + id interface{} +} + +// Enforce that ListLockUnspentCmd satisifies the Cmd interface. +var _ Cmd = &ListLockUnspentCmd{} + +// NewListLockUnspentCmd creates a new ListLockUnspentCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListLockUnspentCmd(id interface{}) (*ListLockUnspentCmd, error) { + return &ListLockUnspentCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListLockUnspentCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListLockUnspentCmd) Method() string { + return "listlockunspent" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListLockUnspentCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listlockunspent", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListLockUnspentCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewListLockUnspentCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListReceivedByAccountCmd is a type handling custom marshaling and +// unmarshaling of listreceivedbyaccount JSON RPC commands. +type ListReceivedByAccountCmd struct { + id interface{} + MinConf int + IncludeEmpty bool +} + +// Enforce that ListReceivedByAccountCmd satisifies the Cmd interface. +var _ Cmd = &ListReceivedByAccountCmd{} + +// NewListReceivedByAccountCmd creates a new ListReceivedByAccountCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListReceivedByAccountCmd(id interface{}, optArgs ...interface{}) (*ListReceivedByAccountCmd, error) { + minconf := 1 + includeempty := false + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + m, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("first optional argument minconf is not an int") + } + minconf = m + } + if len(optArgs) > 1 { + ie, ok := optArgs[1].(bool) + if !ok { + return nil, errors.New("second optional argument includeempty is not a bool") + } + + includeempty = ie + } + return &ListReceivedByAccountCmd{ + id: id, + MinConf: minconf, + IncludeEmpty: includeempty, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListReceivedByAccountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListReceivedByAccountCmd) Method() string { + return "listreceivedbyaccount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListReceivedByAccountCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listreceivedbyaccount", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.MinConf != 1 || cmd.IncludeEmpty != false { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.IncludeEmpty != false { + raw.Params = append(raw.Params, cmd.IncludeEmpty) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListReceivedByAccountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + minconf, ok := r.Params[0].(float64) + if !ok { + return errors.New("first optional parameter minconf must be a number") + } + optArgs = append(optArgs, minconf) + } + if len(r.Params) > 1 { + includeempty, ok := r.Params[1].(bool) + if !ok { + return errors.New("second optional parameter includeempt must be a bool") + } + optArgs = append(optArgs, includeempty) + } + + newCmd, err := NewListReceivedByAccountCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListReceivedByAddressCmd is a type handling custom marshaling and +// unmarshaling of listreceivedbyaddress JSON RPC commands. +type ListReceivedByAddressCmd struct { + id interface{} + MinConf int + IncludeEmpty bool +} + +// Enforce that ListReceivedByAddressCmd satisifies the Cmd interface. +var _ Cmd = &ListReceivedByAddressCmd{} + +// NewListReceivedByAddressCmd creates a new ListReceivedByAddressCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListReceivedByAddressCmd(id interface{}, optArgs ...interface{}) (*ListReceivedByAddressCmd, error) { + minconf := 1 + includeempty := false + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + m, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("first optional argument minconf is not an int") + } + minconf = m + } + if len(optArgs) > 1 { + ie, ok := optArgs[1].(bool) + if !ok { + return nil, errors.New("second optional argument includeempty is not a bool") + } + + includeempty = ie + } + return &ListReceivedByAddressCmd{ + id: id, + MinConf: minconf, + IncludeEmpty: includeempty, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListReceivedByAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListReceivedByAddressCmd) Method() string { + return "listreceivedbyaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListReceivedByAddressCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listreceivedbyaddress", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.MinConf != 1 || cmd.IncludeEmpty != false { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.IncludeEmpty != false { + raw.Params = append(raw.Params, cmd.IncludeEmpty) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListReceivedByAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + minconf, ok := r.Params[0].(float64) + if !ok { + return errors.New("first optional parameter minconf must be a number") + } + optArgs = append(optArgs, minconf) + } + if len(r.Params) > 1 { + includeempty, ok := r.Params[1].(bool) + if !ok { + return errors.New("second optional parameter includeempt must be a bool") + } + optArgs = append(optArgs, includeempty) + } + + newCmd, err := NewListReceivedByAddressCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListSinceBlockCmd is a type handling custom marshaling and +// unmarshaling of listsinceblock JSON RPC commands. +type ListSinceBlockCmd struct { + id interface{} + BlockHash string + TargetConfirmations int +} + +// Enforce that ListSinceBlockCmd satisifies the Cmd interface. +var _ Cmd = &ListSinceBlockCmd{} + +// NewListSinceBlockCmd creates a new ListSinceBlockCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListSinceBlockCmd(id interface{}, optArgs ...interface{}) (*ListSinceBlockCmd, error) { + blockhash := "" + targetconfirmations := 1 + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + bh, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument blockhash is not a string") + } + blockhash = bh + } + if len(optArgs) > 1 { + tc, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("second optional argument targetconfirmations is not an int") + } + + targetconfirmations = tc + } + return &ListSinceBlockCmd{ + id: id, + BlockHash: blockhash, + TargetConfirmations: targetconfirmations, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListSinceBlockCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListSinceBlockCmd) Method() string { + return "listsinceblock" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListSinceBlockCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listsinceblock", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.BlockHash != "" || cmd.TargetConfirmations != 1 { + raw.Params = append(raw.Params, cmd.BlockHash) + } + + if cmd.TargetConfirmations != 1 { + raw.Params = append(raw.Params, cmd.TargetConfirmations) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListSinceBlockCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 0 { + blockhash, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter blockhash must be a string") + } + optArgs = append(optArgs, blockhash) + } + if len(r.Params) > 1 { + targetconfirmations, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter targetconfirmations must be a number") + } + optArgs = append(optArgs, int(targetconfirmations)) + } + + newCmd, err := NewListSinceBlockCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListTransactionsCmd is a type handling custom marshaling and +// unmarshaling of listtransactions JSON RPC commands. +type ListTransactionsCmd struct { + id interface{} + Account string + Count int + From int +} + +// Enforce that ListTransactionsCmd satisifies the Cmd interface. +var _ Cmd = &ListTransactionsCmd{} + +// NewListTransactionsCmd creates a new ListTransactionsCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListTransactionsCmd(id interface{}, optArgs ...interface{}) (*ListTransactionsCmd, error) { + account := "" + count := 10 + from := 0 + + if len(optArgs) > 3 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + ac, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional argument account is not a string") + } + account = ac + } + if len(optArgs) > 1 { + cnt, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("second optional argument count is not an int") + } + + count = cnt + } + if len(optArgs) > 2 { + frm, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("third optional argument from is not an int") + } + + from = frm + } + return &ListTransactionsCmd{ + id: id, + Account: account, + Count: count, + From: from, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListTransactionsCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListTransactionsCmd) Method() string { + return "listtransactions" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListTransactionsCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listtransactions", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.Account != "" || cmd.Count != 10 || cmd.From != 0 { + raw.Params = append(raw.Params, cmd.Account) + } + + if cmd.Count != 10 || cmd.From != 0 { + raw.Params = append(raw.Params, cmd.Count) + } + if cmd.From != 0 { + raw.Params = append(raw.Params, cmd.From) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListTransactionsCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 3 { + return ErrWrongNumberOfParams + } + + optArgs := make([]interface{}, 0, 3) + if len(r.Params) > 0 { + account, ok := r.Params[0].(string) + if !ok { + return errors.New("first optional parameter account must be a string") + } + optArgs = append(optArgs, account) + } + if len(r.Params) > 1 { + count, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter count must be a number") + } + optArgs = append(optArgs, int(count)) + } + if len(r.Params) > 2 { + from, ok := r.Params[2].(float64) + if !ok { + return errors.New("third optional parameter from must be a number") + } + optArgs = append(optArgs, int(from)) + } + + newCmd, err := NewListTransactionsCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ListUnspentCmd is a type handling custom marshaling and +// unmarshaling of listunspent JSON RPC commands. +type ListUnspentCmd struct { + id interface{} + MinConf int + MaxConf int +} + +// Enforce that ListUnspentCmd satisifies the Cmd interface. +var _ Cmd = &ListUnspentCmd{} + +// NewListUnspentCmd creates a new ListUnspentCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewListUnspentCmd(id interface{}, optArgs ...int) (*ListUnspentCmd, error) { + minconf := 1 + maxconf := 999999 + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + if len(optArgs) > 0 { + minconf = optArgs[0] + } + if len(optArgs) > 1 { + maxconf = optArgs[1] + } + return &ListUnspentCmd{ + id: id, + MinConf: minconf, + MaxConf: maxconf, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ListUnspentCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ListUnspentCmd) Method() string { + return "listunspent" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ListUnspentCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "listunspent", + Id: cmd.id, + Params: []interface{}{}, + } + + if cmd.MinConf != 1 || cmd.MaxConf != 99999 { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.MaxConf != 99999 { + raw.Params = append(raw.Params, cmd.MaxConf) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ListUnspentCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]int, 0, 2) + if len(r.Params) > 0 { + minconf, ok := r.Params[0].(float64) + if !ok { + return errors.New("first optional parameter minconf must be a number") + } + optArgs = append(optArgs, int(minconf)) + } + if len(r.Params) > 1 { + maxconf, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter maxconf must be a number") + } + optArgs = append(optArgs, int(maxconf)) + } + + newCmd, err := NewListUnspentCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// LockUnspentCmd is a type handling custom marshaling and +// unmarshaling of lockunspent JSON RPC commands. +type LockUnspentCmd struct { + id interface{} + Unlock bool + Transactions []TransactionInput +} + +// Enforce that LockUnspentCmd satisifies the Cmd interface. +var _ Cmd = &LockUnspentCmd{} + +// NewLockUnspentCmd creates a new LockUnspentCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewLockUnspentCmd(id interface{}, unlock bool, optArgs ...[]TransactionInput) (*LockUnspentCmd, error) { + var transactions []TransactionInput + + if len(optArgs) > 1 { + return nil, ErrWrongNumberOfParams + } + + if len(optArgs) > 0 { + transactions = optArgs[0] + } + + return &LockUnspentCmd{ + id: id, + Unlock: unlock, + Transactions: transactions, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *LockUnspentCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *LockUnspentCmd) Method() string { + return "lockunspent" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *LockUnspentCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "lockunspent", + Id: cmd.id, + Params: []interface{}{ + cmd.Unlock, + }, + } + + if len(cmd.Transactions) > 0 { + raw.Params = append(raw.Params, cmd.Transactions) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *LockUnspentCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 || len(r.Params) < 1 { + return ErrWrongNumberOfParams + } + + unlock, ok := r.Params[0].(bool) + if !ok { + return errors.New("first parameter unlock must be a number") + } + + optArgs := make([][]TransactionInput, 0, 1) + if len(r.Params) > 1 { + iinputs, ok := r.Params[1].([]map[string]interface{}) + if !ok { + return errors.New("second optional parameter transactions must be an array of objects") + } + inputs := make([]TransactionInput, len(iinputs)) + for i, v := range iinputs { + if len(v) != 2 { + return errors.New("input with wrong number of members") + } + txid, ok := v["txid"] + if !ok { + return errors.New("input without txid") + } + inputs[i].Txid, ok = txid.(string) + if !ok { + return errors.New("input txid isn't a string") + } + + vout, ok := v["vout"] + if !ok { + return errors.New("input without vout") + } + fvout, ok := vout.(float64) + if !ok { + return errors.New("input vout not a number") + } + inputs[i].Vout = int(fvout) + } + optArgs = append(optArgs, inputs) + } + + newCmd, err := NewLockUnspentCmd(r.Id, unlock, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// MoveCmd is a type handling custom marshaling and +// unmarshaling of move JSON RPC commands. +type MoveCmd struct { + id interface{} + FromAccount string + ToAccount string + Amount int64 + MinConf int + Comment string +} + +// Enforce that MoveCmd satisifies the Cmd interface. +var _ Cmd = &MoveCmd{} + +// NewMoveCmd creates a new MoveCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewMoveCmd(id interface{}, fromaccount string, toaccount string, amount int64, optArgs ...interface{}) (*MoveCmd, error) { + minconf := 1 + comment := "" + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + + if len(optArgs) > 0 { + m, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("first optional parameter minconf is not a int64") + } + minconf = m + } + if len(optArgs) > 1 { + c, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("second optional parameter comment is not a string") + } + comment = c + } + + return &MoveCmd{ + id: id, + FromAccount: fromaccount, + ToAccount: toaccount, + Amount: amount, + MinConf: minconf, + Comment: comment, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *MoveCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *MoveCmd) Method() string { + return "move" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *MoveCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "move", + Id: cmd.id, + Params: []interface{}{ + cmd.FromAccount, + cmd.ToAccount, + cmd.Amount, + }, + } + + if cmd.MinConf != 1 || cmd.Comment != "" { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.Comment != "" { + raw.Params = append(raw.Params, cmd.Comment) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *MoveCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 5 || len(r.Params) < 3 { + return ErrWrongNumberOfParams + } + + fromaccount, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter fromaccount must be a string") + } + + toaccount, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter toaccount must be a string") + } + + amount, ok := r.Params[2].(float64) + if !ok { + return errors.New("third parameter toaccount must be a number") + } + + samount, err := JSONToAmount(amount) + if err != nil { + return err + } + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 3 { + minconf, ok := r.Params[3].(float64) + if !ok { + return errors.New("fourth optional parameter minconf must be a number") + } + optArgs = append(optArgs, int(minconf)) + } + if len(r.Params) > 4 { + comment, ok := r.Params[4].(string) + if !ok { + return errors.New("fifth optional parameter comment must be a string") + } + optArgs = append(optArgs, comment) + } + + newCmd, err := NewMoveCmd(r.Id, fromaccount, toaccount, samount, + optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// PingCmd is a type handling custom marshaling and +// unmarshaling of ping JSON RPC commands. +type PingCmd struct { + id interface{} +} + +// Enforce that PingCmd satisifies the Cmd interface. +var _ Cmd = &PingCmd{} + +// NewPingCmd creates a new PingCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewPingCmd(id interface{}) (*PingCmd, error) { + return &PingCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *PingCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *PingCmd) Method() string { + return "ping" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *PingCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "ping", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *PingCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewPingCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SendFromCmd is a type handling custom marshaling and +// unmarshaling of sendfrom JSON RPC commands. +type SendFromCmd struct { + id interface{} + FromAccount string + ToAddress string + Amount int64 + MinConf int + Comment string + CommentTo string +} + +// Enforce that SendFromCmd satisifies the Cmd interface. +var _ Cmd = &SendFromCmd{} + +// NewSendFromCmd creates a new SendFromCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSendFromCmd(id interface{}, fromaccount string, toaddress string, amount int64, optArgs ...interface{}) (*SendFromCmd, error) { + minconf := 1 + comment := "" + commentto := "" + + if len(optArgs) > 3 { + return nil, ErrWrongNumberOfParams + } + + if len(optArgs) > 0 { + m, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("first optional parameter minconf is not a int64") + } + minconf = m + } + if len(optArgs) > 1 { + c, ok := optArgs[1].(string) + if !ok { + return nil, errors.New("second optional parameter comment is not a string") + } + comment = c + } + + if len(optArgs) > 2 { + cto, ok := optArgs[2].(string) + if !ok { + return nil, errors.New("third optional parameter commentto is not a string") + } + commentto = cto + } + + return &SendFromCmd{ + id: id, + FromAccount: fromaccount, + ToAddress: toaddress, + Amount: amount, + MinConf: minconf, + Comment: comment, + CommentTo: commentto, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SendFromCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SendFromCmd) Method() string { + return "sendfrom" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SendFromCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "sendfrom", + Id: cmd.id, + Params: []interface{}{ + cmd.FromAccount, + cmd.ToAddress, + float64(cmd.Amount) / 1e8, //convert to BTC + }, + } + + if cmd.MinConf != 1 || cmd.Comment != "" || cmd.CommentTo != "" { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.Comment != "" || cmd.CommentTo != "" { + raw.Params = append(raw.Params, cmd.Comment) + } + + if cmd.CommentTo != "" { + raw.Params = append(raw.Params, cmd.CommentTo) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SendFromCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 6 || len(r.Params) < 3 { + return ErrWrongNumberOfParams + } + + fromaccount, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter fromaccount must be a string") + } + + toaccount, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter toaccount must be a string") + } + + amount, ok := r.Params[2].(float64) + if !ok { + return errors.New("third parameter toaccount must be a number") + } + + samount, err := JSONToAmount(amount) + if err != nil { + return err + } + + optArgs := make([]interface{}, 0, 3) + if len(r.Params) > 3 { + minconf, ok := r.Params[3].(float64) + if !ok { + return errors.New("fourth optional parameter minconf must be a number") + } + + optArgs = append(optArgs, int(minconf)) + } + if len(r.Params) > 4 { + comment, ok := r.Params[4].(string) + if !ok { + return errors.New("fifth optional parameter comment must be a string") + } + optArgs = append(optArgs, comment) + } + if len(r.Params) > 5 { + commentto, ok := r.Params[5].(string) + if !ok { + return errors.New("sixth optional parameter commentto must be a string") + } + optArgs = append(optArgs, commentto) + } + + newCmd, err := NewSendFromCmd(r.Id, fromaccount, toaccount, samount, + optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SendManyCmd is a type handling custom marshaling and +// unmarshaling of sendmany JSON RPC commands. +type SendManyCmd struct { + id interface{} + FromAccount string + Amounts map[string]int64 + MinConf int + Comment string +} + +// Enforce that SendManyCmd satisifies the Cmd interface. +var _ Cmd = &SendManyCmd{} + +// NewSendManyCmd creates a new SendManyCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSendManyCmd(id interface{}, fromaccount string, amounts map[string]int64, optArgs ...interface{}) (*SendManyCmd, error) { + minconf := 1 + comment := "" + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + + if len(optArgs) > 0 { + m, ok := optArgs[0].(int) + if !ok { + return nil, errors.New("first optional parameter minconf is not a int64") + } + minconf = m + } + if len(optArgs) > 1 { + c, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("second optional parameter comment is not a string") + } + comment = c + } + + return &SendManyCmd{ + id: id, + FromAccount: fromaccount, + Amounts: amounts, + MinConf: minconf, + Comment: comment, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SendManyCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SendManyCmd) Method() string { + return "sendmany" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SendManyCmd) MarshalJSON() ([]byte, error) { + floatAmount := make(map[string]float64) + + for k, v := range cmd.Amounts { + floatAmount[k] = float64(v) / 1e8 + } + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "sendmany", + Id: cmd.id, + Params: []interface{}{ + cmd.FromAccount, + floatAmount, + }, + } + + if cmd.MinConf != 1 || cmd.Comment != "" { + raw.Params = append(raw.Params, cmd.MinConf) + } + + if cmd.Comment != "" { + raw.Params = append(raw.Params, cmd.Comment) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SendManyCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 6 || len(r.Params) < 3 { + return ErrWrongNumberOfParams + } + + fromaccount, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter fromaccount must be a string") + } + + famounts, ok := r.Params[1].(map[string]float64) + if !ok { + return errors.New("second parameter toaccount must be a string to number map") + } + + amounts := make(map[string]int64) + for k, v := range famounts { + var err error + amounts[k], err = JSONToAmount(v) + if err != nil { + return err + } + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 2 { + minconf, ok := r.Params[2].(float64) + if !ok { + return errors.New("third optional parameter minconf must be a number") + } + + optArgs = append(optArgs, int(minconf)) + } + if len(r.Params) > 3 { + comment, ok := r.Params[3].(string) + if !ok { + return errors.New("fourth optional parameter comment must be a string") + } + optArgs = append(optArgs, comment) + } + + newCmd, err := NewSendManyCmd(r.Id, fromaccount, amounts, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SendRawTransactionCmd is a type handling custom marshaling and +// unmarshaling of sendrawtransaction JSON RPC commands. +type SendRawTransactionCmd struct { + id interface{} + HexTx string +} + +// Enforce that SendRawTransactionCmd satisifies the Cmd interface. +var _ Cmd = &SendRawTransactionCmd{} + +// NewSendRawTransactionCmd creates a new SendRawTransactionCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSendRawTransactionCmd(id interface{}, hextx string) (*SendRawTransactionCmd, error) { + + return &SendRawTransactionCmd{ + id: id, + HexTx: hextx, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SendRawTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SendRawTransactionCmd) Method() string { + return "sendrawtransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SendRawTransactionCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "sendrawtransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.HexTx, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SendRawTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + hextx, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter hextx must be a string") + } + + newCmd, err := NewSendRawTransactionCmd(r.Id, hextx) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SendToAddressCmd is a type handling custom marshaling and +// unmarshaling of sendtoaddress JSON RPC commands. +type SendToAddressCmd struct { + id interface{} + Address string + Amount int64 + Comment string + CommentTo string +} + +// Enforce that SendToAddressCmd satisifies the Cmd interface. +var _ Cmd = &SendToAddressCmd{} + +// NewSendToAddressCmd creates a new SendToAddressCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSendToAddressCmd(id interface{}, address string, amount int64, optArgs ...interface{}) (*SendToAddressCmd, error) { + comment := "" + commentto := "" + + if len(optArgs) > 2 { + return nil, ErrWrongNumberOfParams + } + + if len(optArgs) > 0 { + c, ok := optArgs[0].(string) + if !ok { + return nil, errors.New("first optional parameter comment is not a string") + } + comment = c + } + if len(optArgs) > 1 { + cto, ok := optArgs[1].(string) + if !ok { + return nil, errors.New("second optional parameter commentto is not a string") + } + commentto = cto + } + + return &SendToAddressCmd{ + id: id, + Address: address, + Amount: amount, + Comment: comment, + CommentTo: commentto, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SendToAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SendToAddressCmd) Method() string { + return "sendtoaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SendToAddressCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "sendtoaddress", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + float64(cmd.Amount) / 1e8, //convert to BTC + }, + } + + if cmd.Comment != "" || cmd.CommentTo != "" { + raw.Params = append(raw.Params, cmd.Comment) + } + + if cmd.CommentTo != "" { + raw.Params = append(raw.Params, cmd.CommentTo) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SendToAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 4 || len(r.Params) < 2 { + return ErrWrongNumberOfParams + } + + toaccount, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter toaccount must be a string") + } + + amount, ok := r.Params[1].(float64) + if !ok { + return errors.New("second parameter amount must be a number") + } + + samount, err := JSONToAmount(amount) + if err != nil { + return err + } + + optArgs := make([]interface{}, 0, 2) + if len(r.Params) > 3 { + comment, ok := r.Params[3].(string) + if !ok { + return errors.New("third optional parameter comment must be a string") + } + optArgs = append(optArgs, comment) + } + if len(r.Params) > 4 { + commentto, ok := r.Params[4].(string) + if !ok { + return errors.New("sixth optional parameter commentto must be a string") + } + optArgs = append(optArgs, commentto) + } + + newCmd, err := NewSendToAddressCmd(r.Id, toaccount, samount, + optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SetAccountCmd is a type handling custom marshaling and +// unmarshaling of setaccount JSON RPC commands. +type SetAccountCmd struct { + id interface{} + Address string + Account string +} + +// Enforce that SetAccountCmd satisifies the Cmd interface. +var _ Cmd = &SetAccountCmd{} + +// NewSetAccountCmd creates a new SetAccountCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSetAccountCmd(id interface{}, address string, account string) (*SetAccountCmd, error) { + + return &SetAccountCmd{ + id: id, + Address: address, + Account: account, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SetAccountCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SetAccountCmd) Method() string { + return "setaccount" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SetAccountCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "setaccount", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + cmd.Account, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SetAccountCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 || len(r.Params) < 2 { + return ErrWrongNumberOfParams + } + + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be a string") + } + + account, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter account must be a string") + } + + newCmd, err := NewSetAccountCmd(r.Id, address, account) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SetGenerateCmd is a type handling custom marshaling and +// unmarshaling of setgenerate JSON RPC commands. +type SetGenerateCmd struct { + id interface{} + Generate bool + GenProcLimit int +} + +// Enforce that SetGenerateCmd satisifies the Cmd interface. +var _ Cmd = &SetGenerateCmd{} + +// NewSetGenerateCmd creates a new SetGenerateCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSetGenerateCmd(id interface{}, generate bool, optArgs ...int) (*SetGenerateCmd, error) { + + genproclimit := 0 + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + if len(optArgs) == 1 { + genproclimit = optArgs[0] + } + + return &SetGenerateCmd{ + id: id, + Generate: generate, + GenProcLimit: genproclimit, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SetGenerateCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SetGenerateCmd) Method() string { + return "setgenerate" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SetGenerateCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "setgenerate", + Id: cmd.id, + Params: []interface{}{ + cmd.Generate, + }, + } + + if cmd.GenProcLimit != 0 { + raw.Params = append(raw.Params, cmd.GenProcLimit) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SetGenerateCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 || len(r.Params) < 1 { + return ErrWrongNumberOfParams + } + + generate, ok := r.Params[0].(bool) + if !ok { + return errors.New("first parameter generate must be a bool") + } + + optArgs := make([]int, 0, 1) + if len(r.Params) > 1 { + genproclimit, ok := r.Params[1].(float64) + if !ok { + return errors.New("second parameter genproclimit must be a number") + } + optArgs = append(optArgs, int(genproclimit)) + } + + newCmd, err := NewSetGenerateCmd(r.Id, generate, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SetTxFeeCmd is a type handling custom marshaling and +// unmarshaling of settxfee JSON RPC commands. +type SetTxFeeCmd struct { + id interface{} + Amount int64 +} + +// Enforce that SetTxFeeCmd satisifies the Cmd interface. +var _ Cmd = &SetTxFeeCmd{} + +// NewSetTxFeeCmd creates a new SetTxFeeCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSetTxFeeCmd(id interface{}, amount int64) (*SetTxFeeCmd, error) { + return &SetTxFeeCmd{ + id: id, + Amount: amount, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SetTxFeeCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SetTxFeeCmd) Method() string { + return "settxfee" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SetTxFeeCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "settxfee", + Id: cmd.id, + Params: []interface{}{ + cmd.Amount, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SetTxFeeCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + amount, ok := r.Params[0].(float64) + if !ok { + return errors.New("first parameter amount must be a number") + } + + samount, err := JSONToAmount(amount) + if err != nil { + return err + } + + newCmd, err := NewSetTxFeeCmd(r.Id, samount) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SignMessageCmd is a type handling custom marshaling and +// unmarshaling of signmessage JSON RPC commands. +type SignMessageCmd struct { + id interface{} + Address string + Message string +} + +// Enforce that SignMessageCmd satisifies the Cmd interface. +var _ Cmd = &SignMessageCmd{} + +// NewSignMessageCmd creates a new SignMessageCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSignMessageCmd(id interface{}, address string, message string) (*SignMessageCmd, error) { + return &SignMessageCmd{ + id: id, + Address: address, + Message: message, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SignMessageCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SignMessageCmd) Method() string { + return "signmessage" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SignMessageCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "signmessage", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + cmd.Message, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SignMessageCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be a string") + } + + message, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter message must be a string") + } + + newCmd, err := NewSignMessageCmd(r.Id, address, message) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +type RawTxInput struct { + Txid string `json:"txid"` + Vout int `json:"vout"` + ScriptPubKey string `json:"scriptPubKey"` +} + +// SignRawTransactionCmd is a type handling custom marshaling and +// unmarshaling of signrawtransaction JSON RPC commands. +type SignRawTransactionCmd struct { + id interface{} + RawTx string + Inputs []RawTxInput + PrivKeys []string + Flags string +} + +// Enforce that SignRawTransactionCmd satisifies the Cmd interface. +var _ Cmd = &SignRawTransactionCmd{} + +// NewSignRawTransactionCmd creates a new SignRawTransactionCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSignRawTransactionCmd(id interface{}, rawTx string, optArgs ...interface{}) (*SignRawTransactionCmd, error) { + var inputs []RawTxInput + var privkeys []string + var flags string + if len(optArgs) > 3 { + return nil, ErrTooManyOptArgs + } + if len(optArgs) > 0 { + ip, ok := optArgs[0].([]RawTxInput) + if !ok { + return nil, errors.New("first optional parameter inputs should be an array of RawTxInput") + } + + inputs = ip + } + if len(optArgs) > 1 { + pk, ok := optArgs[1].([]string) + if !ok { + return nil, errors.New("second optional parameter inputs should be an array of string") + } + + privkeys = pk + } + if len(optArgs) > 2 { + pk, ok := optArgs[2].([]string) + if !ok { + return nil, errors.New("third optional parameter flags should be a string") + } + + privkeys = pk + } + return &SignRawTransactionCmd{ + id: id, + RawTx: rawTx, + Inputs: inputs, + PrivKeys: privkeys, + Flags: flags, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SignRawTransactionCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SignRawTransactionCmd) Method() string { + return "signrawtransaction" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SignRawTransactionCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "signrawtransaction", + Id: cmd.id, + Params: []interface{}{ + cmd.RawTx, + }, + } + + if len(cmd.Inputs) > 0 || len(cmd.PrivKeys) > 0 || cmd.Flags != "" { + raw.Params = append(raw.Params, cmd.Inputs) + } + if len(cmd.PrivKeys) > 0 || cmd.Flags != "" { + raw.Params = append(raw.Params, cmd.PrivKeys) + } + if cmd.Flags != "" { + raw.Params = append(raw.Params, cmd.Flags) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SignRawTransactionCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 4 || len(r.Params) < 1 { + return ErrWrongNumberOfParams + } + + rawtx, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter rawtx must be a string") + } + + optArgs := make([]interface{}, 0, 3) + if len(r.Params) > 1 { + ip, ok := r.Params[1].([]interface{}) + if !ok { + return errors.New("second optional parameter inputs must be an array") + } + inputs := make([]RawTxInput, len(ip)) + for i, val := range ip { + mip, ok := val.(map[string]interface{}) + if !ok { + return errors.New("second optional parameter inputs must be an array of objects") + } + txid, ok := mip["txid"] + if !ok { + return errors.New("txid missing in input object") + } + + inputs[i].Txid, ok = txid.(string) + if !ok { + return errors.New("txid not a string in input object") + } + + vout, ok := mip["vout"] + if !ok { + return errors.New("vout missing in input object") + } + fvout, ok := vout.(float64) + if !ok { + return errors.New("vout not a number in input object") + } + inputs[i].Vout = int(fvout) + + scriptpubkey, ok := mip["scriptpubkey"] + if !ok { + return errors.New("scriptpubkey missing in input object") + } + + inputs[i].ScriptPubKey, ok = scriptpubkey.(string) + if !ok { + return errors.New("scriptpubkey not a string in input object") + } + + } + optArgs = append(optArgs, inputs) + } + + if len(r.Params) > 2 { + privkeys, ok := r.Params[2].([]string) + if !ok { + return errors.New("third optional parameter privkeys is not an array of strings") + } + + optArgs = append(optArgs, privkeys) + } + if len(r.Params) > 3 { + flags, ok := r.Params[3].([]string) + if !ok { + return errors.New("fourth optional parameter flags is not a string") + } + + optArgs = append(optArgs, flags) + } + + newCmd, err := NewSignRawTransactionCmd(r.Id, rawtx, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// StopCmd is a type handling custom marshaling and +// unmarshaling of stop JSON RPC commands. +type StopCmd struct { + id interface{} +} + +// Enforce that StopCmd satisifies the Cmd interface. +var _ Cmd = &StopCmd{} + +// NewStopCmd creates a new StopCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewStopCmd(id interface{}) (*StopCmd, error) { + + return &StopCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *StopCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *StopCmd) Method() string { + return "stop" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *StopCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "stop", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *StopCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewStopCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// SubmitBlockOptions represents the optional options struct provided with +// a SubmitBlockCmd command. +type SubmitBlockOptions struct { + // must be provided if server provided a workid with template. + WorkId string `json:"workid,omitempty"` +} + +// SubmitBlockCmd is a type handling custom marshaling and +// unmarshaling of submitblock JSON RPC commands. +type SubmitBlockCmd struct { + id interface{} + HexBlock string + Options *SubmitBlockOptions +} + +// Enforce that SubmitBlockCmd satisifies the Cmd interface. +var _ Cmd = &SubmitBlockCmd{} + +// NewSubmitBlockCmd creates a new SubmitBlockCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewSubmitBlockCmd(id interface{}, hexblock string, optArgs ...*SubmitBlockOptions) (*SubmitBlockCmd, error) { + var options *SubmitBlockOptions + if len(optArgs) > 0 { + if len(optArgs) > 1 { + return nil, ErrTooManyOptArgs + } + options = optArgs[0] + } + + return &SubmitBlockCmd{ + id: id, + HexBlock: hexblock, + Options: options, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *SubmitBlockCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *SubmitBlockCmd) Method() string { + return "submitblock" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *SubmitBlockCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "submitblock", + Id: cmd.id, + Params: []interface{}{ + cmd.HexBlock, + }, + } + + if cmd.Options != nil { + raw.Params = append(raw.Params, cmd.Options) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *SubmitBlockCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 || len(r.Params) < 1 { + return ErrWrongNumberOfParams + } + + hexblock, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter hexblock must be a string") + } + + optArgs := make([]*SubmitBlockOptions, 0, 1) + if len(r.Params) == 2 { + obj, ok := r.Params[1].(map[string]interface{}) + if !ok { + return errors.New("second optioanl parameter options must be an object") + } + options := new(SubmitBlockOptions) + + // workid is optional + iworkid, ok := obj["workid"] + if ok { + workid, ok := iworkid.(string) + if !ok { + return errors.New("object member workid must be a string") + } + options.WorkId = workid + } + optArgs = append(optArgs, options) + } + + newCmd, err := NewSubmitBlockCmd(r.Id, hexblock, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// ValidateAddressCmd is a type handling custom marshaling and +// unmarshaling of validateaddress JSON RPC commands. +type ValidateAddressCmd struct { + id interface{} + Address string +} + +// Enforce that ValidateAddressCmd satisifies the Cmd interface. +var _ Cmd = &ValidateAddressCmd{} + +// NewValidateAddressCmd creates a new ValidateAddressCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewValidateAddressCmd(id interface{}, address string) (*ValidateAddressCmd, error) { + + return &ValidateAddressCmd{ + id: id, + Address: address, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *ValidateAddressCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *ValidateAddressCmd) Method() string { + return "validateaddress" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *ValidateAddressCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "validateaddress", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *ValidateAddressCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 1 { + return ErrWrongNumberOfParams + } + + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be a string") + } + + newCmd, err := NewValidateAddressCmd(r.Id, address) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// VerifyChainCmd is a type handling custom marshaling and +// unmarshaling of verifychain JSON RPC commands. +type VerifyChainCmd struct { + id interface{} + CheckLevel int + CheckDepth int +} + +// Enforce that VerifyChainCmd satisifies the Cmd interface. +var _ Cmd = &VerifyChainCmd{} + +// NewVerifyChainCmd creates a new VerifyChainCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewVerifyChainCmd(id interface{}, optArgs ...int) (*VerifyChainCmd, error) { + // bitcoind default, but they do vary it based on cli args. + var checklevel = 3 + var checkdepth = 288 + + if len(optArgs) > 0 { + if len(optArgs) > 2 { + return nil, ErrTooManyOptArgs + } + checklevel = optArgs[0] + + if len(optArgs) > 1 { + checkdepth = optArgs[1] + } + } + + return &VerifyChainCmd{ + id: id, + CheckLevel: checklevel, + CheckDepth: checkdepth, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *VerifyChainCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *VerifyChainCmd) Method() string { + return "verifychain" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *VerifyChainCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "verifychain", + Id: cmd.id, + Params: []interface{}{}, + } + + // XXX(oga) magic numbers + if cmd.CheckLevel != 3 || cmd.CheckDepth != 288 { + raw.Params = append(raw.Params, cmd.CheckLevel) + } + + if cmd.CheckDepth != 288 { + raw.Params = append(raw.Params, cmd.CheckDepth) + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *VerifyChainCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) > 2 { + return ErrWrongNumberOfParams + } + + optArgs := make([]int, 0, 2) + if len(r.Params) > 0 { + checklevel, ok := r.Params[0].(float64) + if !ok { + return errors.New("first optional parameter checklevel must be a number") + } + + optArgs = append(optArgs, int(checklevel)) + } + + if len(r.Params) > 1 { + checkdepth, ok := r.Params[1].(float64) + if !ok { + return errors.New("second optional parameter checkdepth must be a number") + } + + optArgs = append(optArgs, int(checkdepth)) + } + + newCmd, err := NewVerifyChainCmd(r.Id, optArgs...) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// VerifyMessageCmd is a type handling custom marshaling and +// unmarshaling of verifymessage JSON RPC commands. +type VerifyMessageCmd struct { + id interface{} + Address string + Signature string + Message string +} + +// Enforce that VerifyMessageCmd satisifies the Cmd interface. +var _ Cmd = &VerifyMessageCmd{} + +// NewVerifyMessageCmd creates a new VerifyMessageCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewVerifyMessageCmd(id interface{}, address string, signature string, + message string) (*VerifyMessageCmd, error) { + + return &VerifyMessageCmd{ + id: id, + Address: address, + Signature: signature, + Message: message, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *VerifyMessageCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *VerifyMessageCmd) Method() string { + return "verifymessage" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *VerifyMessageCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "verifymessage", + Id: cmd.id, + Params: []interface{}{ + cmd.Address, + cmd.Signature, + cmd.Message, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *VerifyMessageCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 3 { + return ErrWrongNumberOfParams + } + + address, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter address must be a string") + } + + signature, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter signature must be a string") + } + + message, ok := r.Params[2].(string) + if !ok { + return errors.New("third parameter message must be a string") + } + + newCmd, err := NewVerifyMessageCmd(r.Id, address, signature, message) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// WalletLockCmd is a type handling custom marshaling and +// unmarshaling of walletlock JSON RPC commands. +type WalletLockCmd struct { + id interface{} +} + +// Enforce that WalletLockCmd satisifies the Cmd interface. +var _ Cmd = &WalletLockCmd{} + +// NewWalletLockCmd creates a new WalletLockCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewWalletLockCmd(id interface{}) (*WalletLockCmd, error) { + + return &WalletLockCmd{ + id: id, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *WalletLockCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *WalletLockCmd) Method() string { + return "walletlock" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *WalletLockCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "walletlock", + Id: cmd.id, + Params: []interface{}{}, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *WalletLockCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 0 { + return ErrWrongNumberOfParams + } + + newCmd, err := NewWalletLockCmd(r.Id) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// WalletPassphraseCmd is a type handling custom marshaling and +// unmarshaling of walletpassphrase JSON RPC commands. +type WalletPassphraseCmd struct { + id interface{} + Passphrase string + Timeout int64 +} + +// Enforce that WalletPassphraseCmd satisifies the Cmd interface. +var _ Cmd = &WalletPassphraseCmd{} + +// NewWalletPassphraseCmd creates a new WalletPassphraseCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewWalletPassphraseCmd(id interface{}, passphrase string, timeout int64) (*WalletPassphraseCmd, error) { + + return &WalletPassphraseCmd{ + id: id, + Passphrase: passphrase, + Timeout: timeout, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *WalletPassphraseCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *WalletPassphraseCmd) Method() string { + return "walletpassphrase" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *WalletPassphraseCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "walletpassphrase", + Id: cmd.id, + Params: []interface{}{ + cmd.Passphrase, + cmd.Timeout, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *WalletPassphraseCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + + passphrase, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter passphrase must be a string") + } + + timeout, ok := r.Params[1].(float64) + if !ok { + return errors.New("second parameter timeout must be a number") + } + + newCmd, err := NewWalletPassphraseCmd(r.Id, passphrase, int64(timeout)) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} + +// WalletPassphraseChangeCmd is a type handling custom marshaling and +// unmarshaling of walletpassphrasechange JSON RPC commands. +type WalletPassphraseChangeCmd struct { + id interface{} + OldPassphrase string + NewPassphrase string +} + +// Enforce that WalletPassphraseChangeCmd satisifies the Cmd interface. +var _ Cmd = &WalletPassphraseChangeCmd{} + +// NewWalletPassphraseChangeCmd creates a new WalletPassphraseChangeCmd. Optionally a +// pointer to a TemplateRequest may be provided. +func NewWalletPassphraseChangeCmd(id interface{}, oldpassphrase, newpassphrase string) (*WalletPassphraseChangeCmd, error) { + + return &WalletPassphraseChangeCmd{ + id: id, + OldPassphrase: oldpassphrase, + NewPassphrase: newpassphrase, + }, nil +} + +// Id satisfies the Cmd interface by returning the id of the command. +func (cmd *WalletPassphraseChangeCmd) Id() interface{} { + return cmd.id +} + +// Method satisfies the Cmd interface by returning the json method. +func (cmd *WalletPassphraseChangeCmd) Method() string { + return "walletpassphrasechange" +} + +// MarshalJSON returns the JSON encoding of cmd. Part of the Cmd interface. +func (cmd *WalletPassphraseChangeCmd) MarshalJSON() ([]byte, error) { + raw := RawCmd{ + Jsonrpc: "1.0", + Method: "walletpassphrasechange", + Id: cmd.id, + Params: []interface{}{ + cmd.OldPassphrase, + cmd.NewPassphrase, + }, + } + + return json.Marshal(raw) +} + +// UnmarshalJSON unmarshals the JSON encoding of cmd into cmd. Part of +// the Cmd interface. +func (cmd *WalletPassphraseChangeCmd) UnmarshalJSON(b []byte) error { + // Unmashal into a RawCmd + var r RawCmd + if err := json.Unmarshal(b, &r); err != nil { + return err + } + + if len(r.Params) != 2 { + return ErrWrongNumberOfParams + } + + oldpassphrase, ok := r.Params[0].(string) + if !ok { + return errors.New("first parameter oldpassphrase must be a string") + } + + newpassphrase, ok := r.Params[1].(string) + if !ok { + return errors.New("second parameter newpassphrase must be a string") + } + + newCmd, err := NewWalletPassphraseChangeCmd(r.Id, oldpassphrase, newpassphrase) + if err != nil { + return err + } + + *cmd = *newCmd + return nil +} diff --git a/jsoncmd_test.go b/jsoncmd_test.go new file mode 100644 index 00000000..270020fa --- /dev/null +++ b/jsoncmd_test.go @@ -0,0 +1,193 @@ +// Copyright (c) 2013 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +// this has to be in the real json subpackage so we can mock up structs +package btcjson + +import ( + "encoding/json" + "github.com/davecgh/go-spew/spew" + "reflect" + "testing" +) + +var jsoncmdtests = []struct { + name string + f func() (Cmd, error) + result Cmd // after marshal and unmarshal +}{ + { + name: "basic addmultisigaddress", + f: func() (Cmd, error) { + return NewAddMultisigAddressCmd(float64(1), 1, + []string{"foo", "bar"}) + }, + result: &AddMultisigAddressCmd{ + id: float64(1), + NRequired: 1, + Keys: []string{"foo", "bar"}, + Account: "", + }, + }, + { + name: "addmultisigaddress + optional", + f: func() (Cmd, error) { + return NewAddMultisigAddressCmd(float64(1), 1, + []string{"foo", "bar"}, "address") + }, + result: &AddMultisigAddressCmd{ + id: float64(1), + NRequired: 1, + Keys: []string{"foo", "bar"}, + Account: "address", + }, + }, + // TODO(oga) Too many arguments to newaddmultisigaddress + { + name: "basic addnode add", + f: func() (Cmd, error) { + return NewAddNodeCmd(float64(1), "address", + "add") + }, + result: &AddNodeCmd{ + id: float64(1), + Addr: "address", + SubCmd: "add", + }, + }, + { + name: "basic addnode remoe", + f: func() (Cmd, error) { + return NewAddNodeCmd(float64(1), "address", + "remove") + }, + result: &AddNodeCmd{ + id: float64(1), + Addr: "address", + SubCmd: "remove", + }, + }, + { + name: "basic addnode onetry", + f: func() (Cmd, error) { + return NewAddNodeCmd(float64(1), "address", + "onetry") + }, + result: &AddNodeCmd{ + id: float64(1), + Addr: "address", + SubCmd: "onetry", + }, + }, + // TODO(oga) try invalid subcmds + { + name: "basic backupwallet", + f: func() (Cmd, error) { + return NewBackupWalletCmd(float64(1), "destination") + }, + result: &BackupWalletCmd{ + id: float64(1), + Destination: "destination", + }, + }, + { + name: "basic createmultisig", + f: func() (Cmd, error) { + return NewCreateMultisigCmd(float64(1), 1, + []string{"key1", "key2", "key3"}) + }, + result: &CreateMultisigCmd{ + id: float64(1), + NRequired: 1, + Keys: []string{"key1", "key2", "key3"}, + }, + }, + { + name: "basic createrawtransaction", + f: func() (Cmd, error) { + return NewCreateRawTransactionCmd(float64(1), + []TransactionInput{ + TransactionInput{Txid: "tx1", Vout: 1}, + TransactionInput{Txid: "tx2", Vout: 3}}, + map[string]int64{"bob": 1, "bill": 2}) + }, + result: &CreateRawTransactionCmd{ + id: float64(1), + Inputs: []TransactionInput{ + TransactionInput{Txid: "tx1", Vout: 1}, + TransactionInput{Txid: "tx2", Vout: 3}, + }, + Amounts: map[string]int64{ + "bob": 1, + "bill": 2, + }, + }, + }, + { + name: "basic ping", + f: func() (Cmd, error) { + return NewPingCmd(float64(1)) + }, + result: &PingCmd{ + id: float64(1), + }, + }, + { + name: "basic getblockcount", + f: func() (Cmd, error) { + return NewGetBlockCountCmd(float64(1)) + }, + result: &GetBlockCountCmd{ + id: float64(1), + }, + }, + { + name: "basic getblock", + f: func() (Cmd, error) { + return NewGetBlockCmd(float64(1), + "somehash") + }, + result: &GetBlockCmd{ + id: float64(1), + Hash: "somehash", + }, + }, +} + +func TestCmds(t *testing.T) { + for _, test := range jsoncmdtests { + c, err := test.f() + if err != nil { + t.Errorf("%s: failed to run func: %v", + test.name, err) + continue + } + + msg, err := json.Marshal(c) + if err != nil { + t.Errorf("%s: failed to marshal cmd: %v", + test.name, err) + continue + } + + c2, err := ParseMarshaledCmd(msg) + if err != nil { + t.Errorf("%s: failed to ummarshal cmd: %v", + test.name, err) + continue + } + + if !reflect.DeepEqual(test.result, c2) { + t.Errorf("%s: unmarshal not as expected. "+ + "got %v wanted %v", test.name, spew.Sdump(c2), + spew.Sdump(test.result)) + } + if !reflect.DeepEqual(c, c2) { + t.Errorf("%s: unmarshal not as we started with. "+ + "got %v wanted %v", test.name, spew.Sdump(c2), + spew.Sdump(c)) + } + + } +}